From 07667a4155f4e0fff19cc928d582997a743a2339 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 29 Mar 2024 23:03:45 +0100 Subject: [PATCH 001/141] WIP-ADD: Fast Global Registration added --- src/diffCheck.hh | 3 ++- src/diffCheck/registration/registration.cc | 30 ++++++++++++++++++++++ src/diffCheck/registration/registration.hh | 14 ++++++++++ src/diffCheckApp.cc | 30 +++++++++++++++++----- 4 files changed, 69 insertions(+), 8 deletions(-) create mode 100644 src/diffCheck/registration/registration.cc create mode 100644 src/diffCheck/registration/registration.hh diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 0c05498f..1904a0f7 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -7,4 +7,5 @@ #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" #include "diffCheck/IOManager.hh" -#include "diffCheck/visualizer.hh" \ No newline at end of file +#include "diffCheck/visualizer.hh" +#include "diffCheck/registration/registration.hh" \ No newline at end of file diff --git a/src/diffCheck/registration/registration.cc b/src/diffCheck/registration/registration.cc new file mode 100644 index 00000000..eb24e81a --- /dev/null +++ b/src/diffCheck/registration/registration.cc @@ -0,0 +1,30 @@ +#include "registration.hh" + +namespace diffCheck::registration +{ + open3d::pipelines::registration::RegistrationResult Registration::o3dFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) + { + auto sourceO3d = source->Cvt2O3DPointCloud(); + auto targetO3d = target->Cvt2O3DPointCloud(); + + sourceO3d->RandomDownSample(0.1); + targetO3d->RandomDownSample(0.1); + + std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3d, + open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3d, + open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + std::shared_ptr option = std::make_shared(); + option->maximum_correspondence_distance_ = 0.05; + option->iteration_number_ = 100; + option->maximum_tuple_count_ = 500; + + auto result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(*sourceO3d, + *targetO3d, + *sourceFPFHFeatures, + *targetFPFHFeatures, + *option); + + return result; + } +} // namespace diffCheck::registration \ No newline at end of file diff --git a/src/diffCheck/registration/registration.hh b/src/diffCheck/registration/registration.hh new file mode 100644 index 00000000..b3b88dd0 --- /dev/null +++ b/src/diffCheck/registration/registration.hh @@ -0,0 +1,14 @@ +#pragma once + +#include "diffCheck.hh" +#include + +namespace diffCheck::registration{ + +class Registration +{ + public: + + open3d::pipelines::registration::RegistrationResult o3dFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); +}; +} \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index ec0023bc..722edb83 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -12,23 +12,39 @@ int main() { std::shared_ptr dfPointCloudPtr = std::make_shared(); + std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); + std::shared_ptr dfPointCloudPtrAfterReg = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\andre\Downloads\scan_data_normals.ply\scan_data_normals.ply)"; - std::string pathMesh = R"(F:\diffCheck\assets\dataset\mesh_fromRh_unfixedLength.ply)"; + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; - // create a sphere from o3d - auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); dfMeshPtr->LoadFromPLY(pathMesh); + dfPointCloudPtr->LoadFromPLY(pathCloud); + // create a rigid rotation matrix + Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); + T.block<3, 3>(0, 0) = Eigen::AngleAxisd(3 , Eigen::Vector3d::UnitZ()).toRotationMatrix(); // Yes, Pi = 3 in this case + T(0, 3) = 1; + T(1, 3) = 4; - dfMeshPtr->Cvt2DFMesh(mesh); + std::shared_ptr o3DPC = std::make_shared(dfPointCloudPtr->Cvt2O3DPointCloud()->Transform(T)); + dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPC); + + std::shared_ptr reg = std::make_shared(); + auto result = reg->o3dFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtr); + + // apply the transformation to the source point cloud + Eigen::Matrix + transformation = result.transformation_; + std::shared_ptr o3DPCReg = std::make_shared(dfPointCloudPtrAfterTrans->Cvt2O3DPointCloud()->Transform(transformation)); + dfPointCloudPtrAfterReg->Cvt2DFPointCloud(o3DPCReg); - // dfPointCloudPtr->LoadFromPLY(pathCloud); std::shared_ptr vis = std::make_shared(); - // vis->AddPointCloud(dfPointCloudPtr); + //vis->AddPointCloud(dfPointCloudPtrAfterTrans); + vis->AddPointCloud(dfPointCloudPtrAfterReg); vis->AddMesh(dfMeshPtr); vis->Run(); From f35e0df8019bd95c22d8396c46cdaaa377c584b3 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 29 Mar 2024 23:19:17 +0100 Subject: [PATCH 002/141] WIP: Correction for naming convention --- src/diffCheck/registration/registration.cc | 18 +++++++++--------- src/diffCheck/registration/registration.hh | 2 +- src/diffCheckApp.cc | 15 +++++++-------- 3 files changed, 17 insertions(+), 18 deletions(-) diff --git a/src/diffCheck/registration/registration.cc b/src/diffCheck/registration/registration.cc index eb24e81a..b14be16e 100644 --- a/src/diffCheck/registration/registration.cc +++ b/src/diffCheck/registration/registration.cc @@ -2,25 +2,25 @@ namespace diffCheck::registration { - open3d::pipelines::registration::RegistrationResult Registration::o3dFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) { - auto sourceO3d = source->Cvt2O3DPointCloud(); - auto targetO3d = target->Cvt2O3DPointCloud(); + auto sourceO3D = source->Cvt2O3DPointCloud(); + auto targetO3D = target->Cvt2O3DPointCloud(); - sourceO3d->RandomDownSample(0.1); - targetO3d->RandomDownSample(0.1); + sourceO3D->RandomDownSample(0.1); + targetO3D->RandomDownSample(0.1); - std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3d, + std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); - std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3d, + std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); std::shared_ptr option = std::make_shared(); option->maximum_correspondence_distance_ = 0.05; option->iteration_number_ = 100; option->maximum_tuple_count_ = 500; - auto result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(*sourceO3d, - *targetO3d, + auto result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(*sourceO3D, + *targetO3D, *sourceFPFHFeatures, *targetFPFHFeatures, *option); diff --git a/src/diffCheck/registration/registration.hh b/src/diffCheck/registration/registration.hh index b3b88dd0..95318e22 100644 --- a/src/diffCheck/registration/registration.hh +++ b/src/diffCheck/registration/registration.hh @@ -9,6 +9,6 @@ class Registration { public: - open3d::pipelines::registration::RegistrationResult o3dFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); + open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 722edb83..b22b422c 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -29,21 +29,20 @@ int main() T(0, 3) = 1; T(1, 3) = 4; - std::shared_ptr o3DPC = std::make_shared(dfPointCloudPtr->Cvt2O3DPointCloud()->Transform(T)); - dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPC); + std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(dfPointCloudPtr->Cvt2O3DPointCloud()->Transform(T)); + dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); std::shared_ptr reg = std::make_shared(); - auto result = reg->o3dFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtr); + auto result = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtr); // apply the transformation to the source point cloud - Eigen::Matrix - transformation = result.transformation_; - std::shared_ptr o3DPCReg = std::make_shared(dfPointCloudPtrAfterTrans->Cvt2O3DPointCloud()->Transform(transformation)); - dfPointCloudPtrAfterReg->Cvt2DFPointCloud(o3DPCReg); + Eigen::Matrix transformation = result.transformation_; + std::shared_ptr o3DPointCloudPtrAfterReg = std::make_shared(dfPointCloudPtrAfterTrans->Cvt2O3DPointCloud()->Transform(transformation)); + dfPointCloudPtrAfterReg->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg); std::shared_ptr vis = std::make_shared(); - //vis->AddPointCloud(dfPointCloudPtrAfterTrans); + vis->AddPointCloud(dfPointCloudPtrAfterTrans); vis->AddPointCloud(dfPointCloudPtrAfterReg); vis->AddMesh(dfMeshPtr); vis->Run(); From bf1ccc6989021877c0c1791075350bb5642550e1 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Tue, 2 Apr 2024 22:44:27 +0200 Subject: [PATCH 003/141] WIP-ADD: FastGlobalRegistrationBasedOnFeatureCorrespondence method added to registration class --- src/diffCheck/registration/registration.cc | 55 ++++++++++++++++++++-- src/diffCheck/registration/registration.hh | 2 + src/diffCheckApp.cc | 11 +++-- 3 files changed, 59 insertions(+), 9 deletions(-) diff --git a/src/diffCheck/registration/registration.cc b/src/diffCheck/registration/registration.cc index b14be16e..693558cf 100644 --- a/src/diffCheck/registration/registration.cc +++ b/src/diffCheck/registration/registration.cc @@ -2,10 +2,24 @@ namespace diffCheck::registration { - open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) + /* + Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html + + Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). + point features historigrams generalize this concept by computing point features in a local neighborhood of a point, stored as higher-dimentional historigrams. + + For example, for a given point, you take all the neighboring points within a given radius, and create a complete graph on those vertices. + then for each edge of the graph you compute features that are then stored in a historigram of the original center point from which the sphere and the graph where built. + https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation proposes a simple example of such a historigram. + + PCL's documentation refers to this 2009 TUM PhD thesis (but largely outside the scope of our work): https://mediatum.ub.tum.de/doc/800632/941254.pdf + + Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + */ + open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) { - auto sourceO3D = source->Cvt2O3DPointCloud(); - auto targetO3D = target->Cvt2O3DPointCloud(); + std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); + std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); sourceO3D->RandomDownSample(0.1); targetO3D->RandomDownSample(0.1); @@ -27,4 +41,37 @@ namespace diffCheck::registration return result; } -} // namespace diffCheck::registration \ No newline at end of file + /* + Very little information on this registration method compared to the previous one. + If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them. + https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html + */ + open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target) + { + std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); + std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); + + sourceO3D->RandomDownSample(0.1); + targetO3D->RandomDownSample(0.1); + + std::shared_ptr option = std::make_shared(); + option->maximum_correspondence_distance_ = 0.05; + option->iteration_number_ = 100; + option->maximum_tuple_count_ = 500; + + std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, + open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, + open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + + + open3d::pipelines::registration::CorrespondenceSet correspondanceset; + correspondanceset = open3d::pipelines::registration::CorrespondencesFromFeatures(*sourceFPFHFeatures, *targetFPFHFeatures); + + auto result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnCorrespondence(*sourceO3D, + *targetO3D, + correspondanceset, + *option); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/registration.hh b/src/diffCheck/registration/registration.hh index 95318e22..e60ca1b8 100644 --- a/src/diffCheck/registration/registration.hh +++ b/src/diffCheck/registration/registration.hh @@ -10,5 +10,7 @@ class Registration public: open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); + + open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target); }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index b22b422c..04d2e784 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -16,8 +16,8 @@ int main() std::shared_ptr dfPointCloudPtrAfterReg = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\04_mesh.ply)"; // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; dfMeshPtr->LoadFromPLY(pathMesh); @@ -25,15 +25,16 @@ int main() // create a rigid rotation matrix Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); - T.block<3, 3>(0, 0) = Eigen::AngleAxisd(3 , Eigen::Vector3d::UnitZ()).toRotationMatrix(); // Yes, Pi = 3 in this case - T(0, 3) = 1; - T(1, 3) = 4; + T.block<3, 3>(0, 0) = Eigen::AngleAxisd(3 , Eigen::Vector3d::UnitZ()).toRotationMatrix(); // Yes, Pi = 3 in this world + T(0, 3) = 10; + T(1, 3) = -40; std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(dfPointCloudPtr->Cvt2O3DPointCloud()->Transform(T)); dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); std::shared_ptr reg = std::make_shared(); auto result = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtr); + //auto result = reg->O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtr); // apply the transformation to the source point cloud Eigen::Matrix transformation = result.transformation_; From 7007eab0a1494e704a2d8d30418bdd93700c4fc4 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Wed, 3 Apr 2024 21:46:23 +0200 Subject: [PATCH 004/141] ADD-WIP: Point to point error calculation method added to Registration class --- src/diffCheck/registration/registration.cc | 11 +++++++++++ src/diffCheck/registration/registration.hh | 2 ++ src/diffCheckApp.cc | 13 +++++++++---- 3 files changed, 22 insertions(+), 4 deletions(-) diff --git a/src/diffCheck/registration/registration.cc b/src/diffCheck/registration/registration.cc index 693558cf..64aab1a5 100644 --- a/src/diffCheck/registration/registration.cc +++ b/src/diffCheck/registration/registration.cc @@ -2,6 +2,17 @@ namespace diffCheck::registration { + std::vector Registration::ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target) + { + std::vector errors; + auto O3DSourcePointCloud = source->Cvt2O3DPointCloud(); + auto O3DTargetPointCloud = target->Cvt2O3DPointCloud(); + + std::vector distances; + + distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud); + return distances; + } /* Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html diff --git a/src/diffCheck/registration/registration.hh b/src/diffCheck/registration/registration.hh index e60ca1b8..69779a72 100644 --- a/src/diffCheck/registration/registration.hh +++ b/src/diffCheck/registration/registration.hh @@ -12,5 +12,7 @@ class Registration open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target); + + std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 04d2e784..7273426c 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -14,6 +14,7 @@ int main() std::shared_ptr dfPointCloudPtr = std::make_shared(); std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); std::shared_ptr dfPointCloudPtrAfterReg = std::make_shared(); + std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; @@ -23,6 +24,9 @@ int main() dfMeshPtr->LoadFromPLY(pathMesh); dfPointCloudPtr->LoadFromPLY(pathCloud); + // populate the mesh with points and store it in dfPointCloudPtrGroundTruth + dfPointCloudPtrGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(100000)); + // create a rigid rotation matrix Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); T.block<3, 3>(0, 0) = Eigen::AngleAxisd(3 , Eigen::Vector3d::UnitZ()).toRotationMatrix(); // Yes, Pi = 3 in this world @@ -33,17 +37,18 @@ int main() dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); std::shared_ptr reg = std::make_shared(); - auto result = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtr); - //auto result = reg->O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtr); + //auto result = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtr); + auto result = reg->O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtr); // apply the transformation to the source point cloud Eigen::Matrix transformation = result.transformation_; std::shared_ptr o3DPointCloudPtrAfterReg = std::make_shared(dfPointCloudPtrAfterTrans->Cvt2O3DPointCloud()->Transform(transformation)); dfPointCloudPtrAfterReg->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg); - + std::vector errors = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg, dfPointCloudPtrGroundTruth); + std::cout << "Mean distance: " << std::accumulate(errors.begin(), errors.end(), 0.0) / errors.size() << std::endl; std::shared_ptr vis = std::make_shared(); - vis->AddPointCloud(dfPointCloudPtrAfterTrans); + vis->AddPointCloud(dfPointCloudPtrGroundTruth); vis->AddPointCloud(dfPointCloudPtrAfterReg); vis->AddMesh(dfMeshPtr); vis->Run(); From d9f7014be4f0be8780f7496a10d72537e551c9eb Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Thu, 4 Apr 2024 16:01:13 +0200 Subject: [PATCH 005/141] FIRST commit --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index dbae83cc..f759f948 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,7 @@

+ Temporary repository for diffCheck ## Roadmap From 492c72d95ef79b3c95c3406df69839746891a8a8 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Thu, 4 Apr 2024 16:03:43 +0200 Subject: [PATCH 006/141] ADD: add dataflow diag --- assets/diagram/rhdfexporter.drawio | 158 +++++++++++++++++++++++++++++ 1 file changed, 158 insertions(+) create mode 100644 assets/diagram/rhdfexporter.drawio diff --git a/assets/diagram/rhdfexporter.drawio b/assets/diagram/rhdfexporter.drawio new file mode 100644 index 00000000..a986f367 --- /dev/null +++ b/assets/diagram/rhdfexporter.drawio @@ -0,0 +1,158 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 1a661c61d029e23ba72e03cf6744c3db588c51cd Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 6 Apr 2024 23:23:04 +0200 Subject: [PATCH 007/141] ADD: gitignore for python --- .gitignore | 166 +++++++++++++++++- CMakeLists.txt | 1 - deps/eigen | 2 +- diffCheckEvery.log | 4 +- src/gh/README.md | 1 + src/gh/diffCheck/__init__.py | 0 .../__pycache__/__init__.cpython-38.pyc | Bin 0 -> 132 bytes .../__pycache__/geometries.cpython-38.pyc | Bin 0 -> 1420 bytes src/gh/diffCheck/geometries.py | 62 +++++++ src/gh/diffCheck_app.py | 20 +++ 10 files changed, 251 insertions(+), 5 deletions(-) create mode 100644 src/gh/README.md create mode 100644 src/gh/diffCheck/__init__.py create mode 100644 src/gh/diffCheck/__pycache__/__init__.cpython-38.pyc create mode 100644 src/gh/diffCheck/__pycache__/geometries.cpython-38.pyc create mode 100644 src/gh/diffCheck/geometries.py create mode 100644 src/gh/diffCheck_app.py diff --git a/.gitignore b/.gitignore index 8b07029b..81422a74 100644 --- a/.gitignore +++ b/.gitignore @@ -77,4 +77,168 @@ _deps temp/ # temporary logging file -*.log \ No newline at end of file +*.log + +####################################### +## Python +####################################### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# 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 diff --git a/CMakeLists.txt b/CMakeLists.txt index 3033fdb5..8969f917 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,7 +16,6 @@ if(NOT GIT_SUBMOD_RESULT EQUAL "0") message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules") endif() - #-------------------------------------------------------------------------- # pre-compiled definitions #-------------------------------------------------------------------------- diff --git a/deps/eigen b/deps/eigen index e63d9f6c..b2c9ba2b 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit e63d9f6ccb7f6f29f31241b87c542f3f0ab3112b +Subproject commit b2c9ba2beef4b5fd61513d73911c678e93c8dd9d diff --git a/diffCheckEvery.log b/diffCheckEvery.log index 20fc75ab..65db11f5 100644 --- a/diffCheckEvery.log +++ b/diffCheckEvery.log @@ -2,5 +2,5 @@ arguments: loguru Current dir: F:\diffCheck File verbosity level: 9 date time ( uptime ) [ thread name/id ] file:line v| -2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckEvery.log', mode: 'w', verbosity: 9 -2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckErrors.log', mode: 'w', verbosity: -2 +2024-03-30 14:03:39.030 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckEvery.log', mode: 'w', verbosity: 9 +2024-03-30 14:03:39.031 ( 0.002s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckErrors.log', mode: 'w', verbosity: -2 diff --git a/src/gh/README.md b/src/gh/README.md new file mode 100644 index 00000000..e94c5323 --- /dev/null +++ b/src/gh/README.md @@ -0,0 +1 @@ +This directory contains all the code for the grasshopper plugin of DiffCheck written in CPython. \ No newline at end of file diff --git a/src/gh/diffCheck/__init__.py b/src/gh/diffCheck/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/gh/diffCheck/__pycache__/__init__.cpython-38.pyc b/src/gh/diffCheck/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b13b9668f30d902921d6542f97d0f3a2062467b5 GIT binary patch literal 132 zcmWIL<>g`kf|eb8X(0MBh(HF6K#l_t7qb9~6oz01O-8?!3`HPe1o2BV%_=4(GcCOK%e~5VpOKY|@0Lr96rNMH~<-q@F4csHzG@a6#cvdRbMnwreNZu-RSg%^|BE zkeZ*tp*{95?UfThfD0#PoF+{l!jV6Z$79du@s~YpwHgH4mmh1rKa7xHI9YBsO!lDb z4*-G)nvf9=zn)HM#YEuHK>%xOX z^~!!P!%_LN(Si1L5bKV~)=@H7Qp>c^ov?EZAts=*({LoK`XJPNn8j%kQOG@SXhVI- zK6L#G;DiiG?g@HAINCJd5DaWuuruqN3~jI-L4bzUEt`iao-I1a=cDf`tg3PVDtkPR zMc^QAR~BTgEFOysTG?7Ay$hmNAnNby-rFM)_j>yS8GSp_Dmv;9mK=SVjbx!>skib; z)#5zQbiv~^E;zpj`?U)|XcK$7IN#Ncv*8%+=mxEAQ!ajQ{};2)e(@^44Pn7 zEEe}+)L0_I%9=?Mi>}|OJkIg*oL3FbN0}HWXg4|kJ`R)1l^W+Fi@ zVG(Dk2CsdbWr=EGA}?22E>$s6t1w-nVF)1?h1x;l8fOh=TORe8=P+tkB5+=77`_Kx z?*iPE+R%~iCXqEGI1k1v!PTWJ+@Dm`gg3Q=hN#0^!)@PbEl0=6q}=|W?9vX%-o$mX zp3$J5iO@kkY9o+a&$7_pQ(!vNUmwPW{!okXM*$wJTejz#n-lVx+Jt>G?cMQ)roPXy z5U5U6OZjlV_qtx-ziT7S$hGdWO!7GG2lnR}G=8qTzNY){qN!~ OBhMzD%ouIA8T|*74J5e$ literal 0 HcmV?d00001 diff --git a/src/gh/diffCheck/geometries.py b/src/gh/diffCheck/geometries.py new file mode 100644 index 00000000..0705e473 --- /dev/null +++ b/src/gh/diffCheck/geometries.py @@ -0,0 +1,62 @@ +#! python3 +from dataclasses import dataclass +import typing +import uuid + +@dataclass +class Face: + """ + This class represents a face + """ + name : str + joint_id : int + def __post_init__(self): + self.name = self.name or "Unnamed Face" + self.joint_id = self.joint_id or None + self._is_joint = False + self._id = uuid.uuid4().int + + @property + def is_joint(self): + if self.joint_id: + return True + return False + + @property + def id(self): + return self._id + +@dataclass +class Beam: + """ + This class represents a beam, in diffCheck, a beam is a collection of faces + """ + name : str + faces : typing.List[Face] + + def __post_init__(self): + self.name = self.name or "Unnamed Beam" + self.faces = self.faces or [] + self._has_joint = False + self._id = uuid.uuid4().int + + @property + def id(self): + return self._id + +@dataclass +class Assembly: + """ + This class represents an assembly of beams + """ + beams : typing.List[Beam] + name : str + def __post_init__(self): + self.beams = self.beams or [] + self.name = self.name or "Unnamed Assembly" + + def add_beam(self, beam: Beam): + self.beams.append(beam) + + def remove_beam(self, beam_id: int): + self.beams = [beam for beam in self.beams if beam.id != beam_id] \ No newline at end of file diff --git a/src/gh/diffCheck_app.py b/src/gh/diffCheck_app.py new file mode 100644 index 00000000..89b8c550 --- /dev/null +++ b/src/gh/diffCheck_app.py @@ -0,0 +1,20 @@ +#! python3 +""" + This module is used as entry point to test the package in Rh/Gh +""" + +import os +from diffCheck.geometries import Beam, Assembly + +def main(): + beam1 = Beam("Beam1", True) + beam2 = Beam("Beam2", False) + print(beam1.id) + print(beam2.id) + + assembly = Assembly([beam1, beam2], "Assembly1") + print(assembly.beams) + print(assembly.name) + +if __name__ == "__main__": + main() \ No newline at end of file From 0fe9c50890535889ad61d4c07dba497d9ded86f5 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 6 Apr 2024 23:33:22 +0200 Subject: [PATCH 008/141] WIP-ADD: basic draft for python structure in gh --- .../__pycache__/geometries.cpython-38.pyc | Bin 1420 -> 3939 bytes src/gh/diffCheck/df_geometries.py | 121 +++++ src/gh/diffCheck/diffCheck_app.py | 48 ++ src/gh/diffCheck/geometries.py | 62 --- src/gh/diffCheck_app.py | 20 - src/gh/tester.ghx | 473 ++++++++++++++++++ 6 files changed, 642 insertions(+), 82 deletions(-) create mode 100644 src/gh/diffCheck/df_geometries.py create mode 100644 src/gh/diffCheck/diffCheck_app.py delete mode 100644 src/gh/diffCheck/geometries.py delete mode 100644 src/gh/diffCheck_app.py create mode 100644 src/gh/tester.ghx diff --git a/src/gh/diffCheck/__pycache__/geometries.cpython-38.pyc b/src/gh/diffCheck/__pycache__/geometries.cpython-38.pyc index 370f504e2eb3a9b1a3ca8fda7413fd3246e4bbb2..1c31d0609c6dafcc633119e9f7ec5a7a02faa410 100644 GIT binary patch literal 3939 zcmb_fTa(;I74DWa8jWUVcWq3-5QuOBWRk^%vWrS>ZHyC#P({H&;S2U)myoA>b~T<` zT3VA;nU~mAP`vRRsB(Do58%(}m8bj#p7_4jXm;(Lb$EzWeRTSI&gpZ$)2*A`ZYc2l z`)_AP|7r>GA6AY(9x7K+vV9OGl$?mE97svtnK%Q-e%*nq1g@=ep>%zkoE+lVwXKc`}?NS=Jx2>G9bEDE(lIzT_RLW0Ed05I~ zD4}Bgkatk7p=57@JQ8EE2$XyzV)Alv&hn^_oke7MY%?@<`g<5|pJ%S2YfOX02YDt- zFVmCJGhyh_|GquixvSFA=-R#>KDe8i;oZIcV-0(HKGnHNb#`%aSa#!hG0*Ziouzpk zZ(@GNHHGZpEzVWjbMd)BCrsi5YtpM=sPtHTh8Uqi__{RaGx1L!W_bM~td`t~ZogM} z+tD3M2k)6C=9++nMpUE?t_e5Y3IzWS->ZW*jH8**s73bUw=60 zW5!$jRFU^AZRGyb=I3G@prvJ@fEeoBoKYJU(dI9>%f%b-S9VMfvOL;P9_lE`qlr#X zyR@>T7n-kQaOqC;%)CM_yp>E2^v{i%8}kh`3|euT#n!UYJ2*&H*&w}Ky0Eo$VePsY zwNVpcdbR;V>}((|I!;IWvN%g6zXUiq(G=w!EF_*`r!DmvQ{5kODu zL_ODk}K)?$7)=rxNvdE(TzGl{fV|7HY{(-S@ zuh*)S_9k>R&)l+g14Amve+zZShHdAGYqRi?l^J_K!>B9;w-iK%0SM= z0P@y$W!?)2rxEMGV2`a|Qo$PGOQpUH;YVmQ5!e3SX#yDkzeZWX%?e0Wzt>%dH}g6d zBHqj!B;O|?5RMRLe!%LfxcVV_-$k)oUgIig6IF(Nrz7eHdS67;xS@TVw76*EUKrqO zPuv#}<*VQyQt@Ky4cfY++NklY^#)zF0fcRq!TVXJr}rm^#pRcwY!>0}YR54w@580b zt6{_PHY`toh@P_`Vm2X&5c>Se#TJi+7&l$$;Pi{F`UtF*={aT_bE=bI%{|KQ`5lbN zczYB$pNd!NxnEV_hV_C~@G?4HJf5tM>(t}%bdTySgZE6m7L=<37(WFbw{B=h&27iq??3DGp-vgo%U{GuD%^OU;07}mAL9B(moBr}bN=Tt^bG-Hr!ooNJNsuCGZudp z4{+~)B>(PwjH`fE8Yl1t4DC6kbMc+ZmUmFE46?R_yUcpS`E+qbaZv)@$CibncyqPA zMo;GtwKe(T?qohpCfOA*^+ZUa&+0Av$x4EiWyQ3QEit4VyCL{{SSO?3+gO_`jxq#+ zU1g2e$*oRf^J7+Rj=oH8-9h{|I(~<;N*KI|1zzB8xQ2bb02k`|$5Lm8npVllo&xk* jm7%N>oUu+!8SGa77gspn9{M=!CDYQ@7RqZV=N2c$kZVe}i}5+oBeALca4R@5j9POunzY@@rewsz+cveBRvt!S-v* z^!EORTb5vtNMP^3zDULOXGUCG07ANkdmS5b0`uGl~1-bLy*o zrtYo6&^(L#iFTjGYGN&@$J|vf=zNn+NJLBa&UjCDIoPK9;LKgV6IhZ%7t#dLd^k)+ zXrf-xMw*q{h*EJtH7}Ch_5qQ;`a-YQYY&uk1w5A24g~YN$%{x9HC9~mip+gwHLv4NbEl+oVB?E5e1e4I*L{n)u+nUJwz5T ziP_qU^E}A}Eb#}BODKPla$+H(F5p=M=OHgTZr&)0q~Gn0+P}P=z?Th7Z=xJSLBQH7 zM|qm + + + + + + + 0 + 2 + 2 + + + + + + + 1 + 0 + 8 + + + + + + 103ba181-3a3b-4b4e-b795-e493222bd4e6 + Shaded + 1 + + 100;102;0;255 + + + 100;0;150;0 + + + + + + 638480369678877464 + + false + tester.ghx + + + + + 0 + + + + + + -25 + -200 + + 2.0761244 + + + + + 0 + + + + + + + 0 + + + + + F:\diffCheck\src\gh\diffCheck_app.py + + + + + 2 + + + + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.4.24044.15001 + + + + + RhinoCodePluginGH, Version=8.4.24044.15001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.4.24044.15001 + + 066d0a87-236f-4eae-a0f4-9e42f5327962 + RhinoCodePluginGH + + + + + + + + 4 + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + + true + 2 + + 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 + + dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 + true + true + true + script-sync cpython + scsy-cpy + + false + false + false + + + + + + 181 + 133 + 105 + 44 + + + 228 + 155 + + true + + + + + 2 + 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. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 083c2fe3-a45a-43c1-8f85-ce20a4a69a99 + btn + btn + true + 0 + true + 5f8bfbf4-70d5-46ba-90fa-f3804e9a9032 + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 183 + 135 + 30 + 20 + + + 199.5 + 145 + + true + + + + + + + true + Converts to collection of Breps (Boundary REPresentations) + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + ae8c9c0d-8d6a-4a8c-812a-110846a2031c + brep + brep + true + 0 + true + 0f309845-29e6-43ae-b255-cdb5c2d13da9 + 1 + + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 183 + 155 + 30 + 20 + + + 199.5 + 165 + + true + + + + + + + false + The redirected standard output of the component scriptsync. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 + stdout + stdout + false + 0 + true + 0 + The redirected standard output of the component scriptsync. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 243 + 135 + 41 + 20 + + + 263.5 + 145 + + true + + + + + + + false + Generic example output of the component + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + f5d7e77d-04d1-4395-b52b-651450a4b329 + a + a + false + 0 + true + 0 + Generic example output of the component + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 243 + 155 + 41 + 20 + + + 263.5 + 165 + + true + + + + + + + + + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)


                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self, btn: bool, brep: Rhino.Geometry.Brep):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 5f8bfbf4-70d5-46ba-90fa-f3804e9a9032 + Button + + false + 0 + + + + + + 89 + 134 + 66 + 22 + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + 0f309845-29e6-43ae-b255-cdb5c2d13da9 + Brep + Brep + false + 0 + + + + + + 99 + 164 + 50 + 24 + + + 124.82912 + 176.29893 + + + + + + 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 + 6ffd83cc-a073-46cd-8213-4c0663708aa7 + Panel + + false + 0 + 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 + 1 + Double click to edit panel content… + + + + + + 308 + 112 + 343 + 169 + + 0 + 0 + 0 + + 308.54327 + 112.449066 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + + + + + + 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 + + + + + \ No newline at end of file From 204173240e97f5e672a36e2f1ec528e05ed1b862 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 11:51:48 +0200 Subject: [PATCH 009/141] WIP-CAP: working xml dumper for diffcheck ghcomponent - missing joint detect --- src/gh/diffCheck/df_geometries.py | 96 ++++++++- src/gh/diffCheck/diffCheck_app.py | 64 +++--- src/gh/diffCheck/joint_detector.py | 0 src/gh/tester.ghx | 327 +++++++++++++++++++++++------ 4 files changed, 381 insertions(+), 106 deletions(-) create mode 100644 src/gh/diffCheck/joint_detector.py diff --git a/src/gh/diffCheck/df_geometries.py b/src/gh/diffCheck/df_geometries.py index 05545ce3..72effcef 100644 --- a/src/gh/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/df_geometries.py @@ -1,3 +1,5 @@ +import os +from datetime import datetime from dataclasses import dataclass import typing import uuid @@ -5,6 +7,9 @@ import Rhino import Rhino.Geometry as rg +import xml.etree.ElementTree as ET +from xml.dom.minidom import parseString + @dataclass class DFVertex: @@ -36,8 +41,8 @@ def __post_init__(self): self.vertices = self.vertices or [] self.joint_id = self.joint_id or None - self._is_joint = None - self._id = uuid.uuid4().int + self.__is_joint = False + self.__id = uuid.uuid4().int def __repr__(self): return f"Face vertices: {len(self.vertices)}" @@ -45,12 +50,14 @@ def __repr__(self): @property def is_joint(self): if self.joint_id: + self.__is_joint = True return True + self.__is_joint = False return False @property def id(self): - return self._id + return self.__id @dataclass @@ -69,7 +76,7 @@ def __post_init__(self): raise ValueError("Faces must be of type List[Face]") self.faces = self.faces or [] - self._id = uuid.uuid4().int + self.__id = uuid.uuid4().int @classmethod def from_brep(cls, brep): @@ -97,7 +104,7 @@ def __repr__(self): @property def id(self): - return self._id + return self.__id @dataclass @@ -118,4 +125,81 @@ def add_beam(self, beam: DFBeam): self.beams.append(beam) def remove_beam(self, beam_id: int): - self.beams = [beam for beam in self.beams if beam.id != beam_id] \ No newline at end of file + self.beams = [beam for beam in self.beams if beam.id != beam_id] + + @classmethod + def from_xml(cls, file_path: str): + """ + Create an assembly from an XML file + + :param file_path: The path to the XML file + :return assembly: The assembly object + """ + # parse the XML file + tree = ET.parse(file_path) + root = tree.getroot() + beams : typing.List[DFBeam] = [] + + name = root.get("name") + for beam_elem in root.findall("Beam"): + beam = DFBeam(beam_elem.get("name"), []) + beam._DFBeam__id = int(beam_elem.get("id")) + for face_elem in beam_elem.findall("Face"): + vertices = [] + for vertex_elem in face_elem.findall("Vertex"): + vertex = DFVertex( + float(vertex_elem.get("x")), + float(vertex_elem.get("y")), + float(vertex_elem.get("z")) + ) + vertices.append(vertex) + face = DFFace(vertices) + face._DFFace__id = int(face_elem.get("id")) + face._DFFace__is_joint = bool(face_elem.get("is_joint")) + face_joint : str = face_elem.get("joint_id") + if face_joint != "None": + face.joint_id = int(face_joint) + else: + face.joint_id = None + beam.faces.append(face) + beams.append(beam) + return cls(beams, name) + + def dump_to_xml(self, dir: str): + """ + Dump the assembly to an XML file + + :param dir: The directory to save the XML file + :return xml_string: The pretty XML string + """ + timestamp = datetime.now().strftime("%Y%m%d%H%M%S") + timestamp = "0" + file_path = os.path.join(dir, f"{self.name}_{timestamp}.xml") + + root = ET.Element("Assembly") + root.set("name", self.name) + # dfbeams + for beam in self.beams: + beam_elem = ET.SubElement(root, "Beam") + beam_elem.set("name", beam.name) + beam_elem.set("id", str(beam.id)) + # dffaces + for face in beam.faces: + face_elem = ET.SubElement(beam_elem, "Face") + face_elem.set("id", str(face.id)) + face_elem.set("is_joint", str(face.is_joint)) + face_elem.set("joint_id", str(face.joint_id)) + # dfvertices + for vertex in face.vertices: + vertex_elem = ET.SubElement(face_elem, "Vertex") + vertex_elem.set("x", str(vertex.x)) + vertex_elem.set("y", str(vertex.y)) + vertex_elem.set("z", str(vertex.z)) + tree = ET.ElementTree(root) + xml_string = ET.tostring(root, encoding='unicode') + dom = parseString(xml_string) + pretty_xml = dom.toprettyxml() + with open(file_path, 'w') as f: + f.write(pretty_xml) + + return pretty_xml \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py index 8fb1a9a4..ada805cf 100644 --- a/src/gh/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck_app.py @@ -7,42 +7,40 @@ import Rhino.Geometry as rg import os -from df_geometries import DFVertex, DFFace, DFBeam, DFAssembly # diffCheck.df_geometries - -def main(): - # vertices - vertex1 = DFVertex(1, 2, 3) - vertex2 = DFVertex(4, 5, 6) - vertex3 = DFVertex(7, 8, 9) - vertex4 = DFVertex(10, 11, 12) - vertex5 = DFVertex(13, 14, 15) - # print(vertex1.x) - # print(vertex2.y) - # print(vertex3.z) - - # faces - face1 = DFFace([vertex1, vertex2, vertex3], 1) - face2 = DFFace([vertex4, vertex5, vertex3, vertex4], 2) - face3 = DFFace([vertex1, vertex2, vertex5], 3) - face4 = DFFace([vertex1, vertex2, vertex3, vertex4]) - face5 = DFFace([vertex1, vertex2, vertex3, vertex4, vertex5]) - face6 = DFFace([vertex1, vertex2, vertex3, vertex4, vertex5, vertex1]) - # print(face1.id) - # print(face2.is_joint) - # print(face3.is_joint) +import typing +from df_geometries import DFBeam, DFAssembly # diffCheck.df_geometries + + +def main( + i_breps : typing.List[rg.Brep], + i_export_dir : str + ): + """ + Main function to test the package + :param i_breps: list of breps + :param i_export_dir: directory to export the xml + """ + # beams - beam1 = DFBeam("Beam1", [face1, face2, face3, face4]) - beam2 = DFBeam("Beam2", [face1, face2, face3, face4, face5, face6]) - beam3 = DFBeam.from_brep(brep) - print(beam3) - # print(beam1.id) - # print(beam2.id) + beams : typing.List[DFBeam] = [] + for brep in i_breps: + beam = DFBeam.from_brep(brep) + beams.append(beam) # assembly - assembly = DFAssembly([beam1, beam2], "Assembly1") - print(assembly.beams) - print(assembly) + assembly1 = DFAssembly(beams, "Assembly1") + print(assembly1.beams) + print(assembly1) + + # dump the xml + xml : str = assembly1.dump_to_xml(i_export_dir) + o_xml = xml + + # # (optional) you can also load the xml + # file_path = os.path.join(i_export_dir, "Assembly1_0.xml") + # assembly2 = DFAssembly.from_xml(file_path) if __name__ == "__main__": - main() \ No newline at end of file + main(i_breps, + i_export_dir) \ No newline at end of file diff --git a/src/gh/diffCheck/joint_detector.py b/src/gh/diffCheck/joint_detector.py new file mode 100644 index 00000000..e69de29b diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index 65594ff9..a4e26c31 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - -25 - -200 + 147 + 73 - 2.0761244 + 0.7558541 @@ -69,7 +69,7 @@ - F:\diffCheck\src\gh\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py @@ -99,9 +99,9 @@ - 4 + 7 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -115,7 +115,7 @@ true 2 - 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 + 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 dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 true @@ -130,30 +130,30 @@ - + - 181 - 133 - 105 - 44 + 187 + 123 + 138 + 64 - 228 + 267 155 - true - - 2 + + 3 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 @@ -174,34 +174,69 @@ - + - 183 - 135 - 30 + 189 + 125 + 63 20 - 199.5 - 145 + 222 + 135 - true + true + Converts to collection of text fragments + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + 8f3ff1eb-ddb8-455d-81fb-cb1cf0c575a5 + i_export_dir + i_export_dir + true + 0 + true + 56e42677-eccb-444a-9bab-e6a34770f1dd + 1 + + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 189 + 145 + 63 + 20 + + + 222 + 155 + + + + + + + + 1 true Converts to collection of Breps (Boundary REPresentations) iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= ae8c9c0d-8d6a-4a8c-812a-110846a2031c - brep - brep + i_breps + i_breps true - 0 + 1 true 0f309845-29e6-43ae-b255-cdb5c2d13da9 1 @@ -210,18 +245,17 @@ - + - 183 - 155 - 30 + 189 + 165 + 63 20 - 199.5 - 165 + 222 + 175 - true @@ -245,18 +279,17 @@ - + - 243 - 135 + 282 + 125 41 - 20 + 30 - 263.5 - 145 + 302.5 + 140 - true @@ -266,32 +299,31 @@ false Generic example output of the component - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== f5d7e77d-04d1-4395-b52b-651450a4b329 - a - a + o_xml + o_xml false 0 true 0 Generic example output of the component - 6a184b65-baa3-42d1-a548-3915b401de53 + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 - + - 243 + 282 155 41 - 20 + 30 - 263.5 - 165 + 302.5 + 170 - true @@ -300,7 +332,7 @@ - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)


                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self, btn: bool, brep: Rhino.Geometry.Brep):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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)
 + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)


                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep]):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -337,8 +369,8 @@ - 89 - 134 + 98 + 124 66 22 @@ -367,14 +399,14 @@ - 99 - 164 + 114 + 176 50 24 - 124.82912 - 176.29893 + 139.87042 + 188.27032 @@ -385,14 +417,30 @@ - 1 + 3 {0} - + - 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 + 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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 @@ -427,17 +475,127 @@ - 308 - 112 + 366 + 44 343 - 169 + 73 + + 0 + 0 + 0 + + 366.4111 + 44.67153 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 56e42677-eccb-444a-9bab-e6a34770f1dd + File Path + Path + false + 0 + + + + + + 115 + 149 + 50 + 24 + + + 140.13669 + 161.41502 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\__TEMP\test\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + d5d04f93-3b13-4fa3-8644-243c03f9a7e8 + Panel + + false + 0.10945549979805946 + bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e + 1 + Double click to edit panel content… + + + + + + 426 + 126 + 604 + 183 0 0 0 - 308.54327 - 112.449066 + 426.19714 + 126.91681 @@ -458,6 +616,41 @@ + + + 3ede854e-c753-40eb-84cb-b48008f14fd4 + Text + + + + + Contains a collection of text fragments + bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e + Text + Txt + false + f5d7e77d-04d1-4395-b52b-651450a4b329 + 1 + + + + + + 345 + 158 + 50 + 24 + + + 370.98038 + 170.96075 + + + + + + + @@ -465,7 +658,7 @@ - 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 + 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 From ac89bd5eca09c31beb1cf997cea49a8a6f24e992 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 11:54:08 +0200 Subject: [PATCH 010/141] FIX: timestamp for file working --- src/gh/diffCheck/df_geometries.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/gh/diffCheck/df_geometries.py b/src/gh/diffCheck/df_geometries.py index 72effcef..4f48ef71 100644 --- a/src/gh/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/df_geometries.py @@ -173,7 +173,6 @@ def dump_to_xml(self, dir: str): :return xml_string: The pretty XML string """ timestamp = datetime.now().strftime("%Y%m%d%H%M%S") - timestamp = "0" file_path = os.path.join(dir, f"{self.name}_{timestamp}.xml") root = ET.Element("Assembly") From 3cc8d04fd69cc41247c39b045aa251c096c8be61 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 12:04:28 +0200 Subject: [PATCH 011/141] FIX: minors and typos --- src/gh/diffCheck/diffCheck_app.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py index ada805cf..0e7efd7b 100644 --- a/src/gh/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck_app.py @@ -1,8 +1,4 @@ #! python3 -""" - This module is used as entry point to test the package in Rh/Gh -""" - import Rhino import Rhino.Geometry as rg @@ -21,7 +17,7 @@ def main( :param i_breps: list of breps :param i_export_dir: directory to export the xml """ - + # beams beams : typing.List[DFBeam] = [] for brep in i_breps: From 17364e1d782040c938cc9101dcab47802ac08b74 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 12:17:33 +0200 Subject: [PATCH 012/141] FIX: better button for output component --- src/gh/diffCheck/df_geometries.py | 23 +++-- src/gh/diffCheck/diffCheck_app.py | 21 ++--- src/gh/tester.ghx | 140 ++++++++++++++++++++++-------- 3 files changed, 125 insertions(+), 59 deletions(-) diff --git a/src/gh/diffCheck/df_geometries.py b/src/gh/diffCheck/df_geometries.py index 4f48ef71..631b27c8 100644 --- a/src/gh/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/df_geometries.py @@ -165,16 +165,12 @@ def from_xml(cls, file_path: str): beams.append(beam) return cls(beams, name) - def dump_to_xml(self, dir: str): + def to_xml(self): """ Dump the assembly to an XML file - :param dir: The directory to save the XML file :return xml_string: The pretty XML string """ - timestamp = datetime.now().strftime("%Y%m%d%H%M%S") - file_path = os.path.join(dir, f"{self.name}_{timestamp}.xml") - root = ET.Element("Assembly") root.set("name", self.name) # dfbeams @@ -198,7 +194,18 @@ def dump_to_xml(self, dir: str): xml_string = ET.tostring(root, encoding='unicode') dom = parseString(xml_string) pretty_xml = dom.toprettyxml() - with open(file_path, 'w') as f: - f.write(pretty_xml) - return pretty_xml \ No newline at end of file + return pretty_xml + + def dump(self, pretty_xml : str, dir: str): + """ + Dump the pretty XML to a file + + :param pretty_xml: The pretty XML string + :param dir: The directory to save the XML + """ + timestamp = datetime.now().strftime("%Y%m%d%H%M%S") + file_path = os.path.join(dir, f"{self.name}_{timestamp}.xml") + + with open(file_path, "w") as f: + f.write(pretty_xml) \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py index 0e7efd7b..61cc5684 100644 --- a/src/gh/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck_app.py @@ -8,16 +8,13 @@ from df_geometries import DFBeam, DFAssembly # diffCheck.df_geometries -def main( - i_breps : typing.List[rg.Brep], - i_export_dir : str - ): +if __name__ == "__main__": """ Main function to test the package :param i_breps: list of breps :param i_export_dir: directory to export the xml + :param i_dump: whether to dump the xml """ - # beams beams : typing.List[DFBeam] = [] for brep in i_breps: @@ -30,13 +27,7 @@ def main( print(assembly1) # dump the xml - xml : str = assembly1.dump_to_xml(i_export_dir) - o_xml = xml - - # # (optional) you can also load the xml - # file_path = os.path.join(i_export_dir, "Assembly1_0.xml") - # assembly2 = DFAssembly.from_xml(file_path) - -if __name__ == "__main__": - main(i_breps, - i_export_dir) \ No newline at end of file + xml : str = assembly1.to_xml() + if i_dump: + assembly1.dump(xml, i_export_dir) + o_xml = xml \ No newline at end of file diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index a4e26c31..f8cafec0 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 147 - 73 + 178 + -118 - 0.7558541 + 1.5 @@ -99,9 +99,9 @@ - 7 + 8 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -133,9 +133,9 @@ 187 - 123 + 113 138 - 64 + 84 267 @@ -144,16 +144,17 @@ - - 3 + + 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 @@ -177,19 +178,54 @@ 189 - 125 + 115 63 20 222 - 135 + 125 + + true + Converts to collection of boolean values + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 509e66b1-9c06-47bc-9e26-3bcd45a184ca + i_dump + i_dump + true + 0 + true + 5de6f2a8-d2d0-49e6-92b4-ae1ed47ccbfd + 1 + + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 189 + 135 + 63 + 20 + + + 222 + 145 + + + + + + true Converts to collection of text fragments @@ -212,19 +248,19 @@ 189 - 145 + 155 63 20 222 - 155 + 165 - + 1 true @@ -248,13 +284,13 @@ 189 - 165 + 175 63 20 222 - 175 + 185 @@ -282,13 +318,13 @@ 282 - 125 + 115 41 - 30 + 40 302.5 - 140 + 135 @@ -318,11 +354,11 @@ 282 155 41 - 30 + 40 302.5 - 170 + 175 @@ -332,7 +368,7 @@ - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)


                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep]):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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)
 + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)


                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_dump: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep]):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -369,8 +405,8 @@ - 98 - 124 + 102 + 97 66 22 @@ -399,14 +435,14 @@ - 114 - 176 + 118 + 181 50 24 - 139.87042 - 188.27032 + 143.71587 + 193.00317 @@ -432,7 +468,7 @@ - 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 + 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 00000000-0000-0000-0000-000000000000 @@ -440,7 +476,7 @@ - 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 + 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 00000000-0000-0000-0000-000000000000 @@ -527,14 +563,14 @@ - 115 - 149 + 118 + 154 50 24 - 140.13669 - 161.41502 + 143.98213 + 166.14787 @@ -651,6 +687,38 @@ + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 5de6f2a8-d2d0-49e6-92b4-ae1ed47ccbfd + Button + dump! + false + 0 + + + + + + 68 + 127 + 102 + 22 + + + + + + + @@ -658,7 +726,7 @@ - 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 + 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 From 9db6763cab1b78d1721baafbf2b4a33d68b61b78 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 14:22:47 +0200 Subject: [PATCH 013/141] WIP: testing componentizer action --- .github/actions/ghpython-components/README.md | 1 + .../actions/ghpython-components/action.yml | 32 ++ .../ghpython-components/componentize.py | 396 ++++++++++++++++++ .github/workflows/gh_build.yml | 38 ++ README.md | 1 + src/gh/components/xml_exporter/code.py | 49 +++ src/gh/components/xml_exporter/icon.png | Bin 0 -> 5660 bytes src/gh/components/xml_exporter/metadata.json | 68 +++ src/gh/{ => diffCheck}/README.md | 0 .../__pycache__/__init__.cpython-38.pyc | Bin 132 -> 0 bytes .../__pycache__/geometries.cpython-38.pyc | Bin 3939 -> 0 bytes src/gh/diffCheck/{ => diffCheck}/__init__.py | 0 .../{ => diffCheck}/df_geometries.py | 0 .../{ => diffCheck}/diffCheck_app.py | 0 .../{ => diffCheck}/joint_detector.py | 0 src/gh/diffCheck/setup.py | 18 + src/gh/tester.ghx | 78 ++-- 17 files changed, 642 insertions(+), 39 deletions(-) create mode 100644 .github/actions/ghpython-components/README.md create mode 100644 .github/actions/ghpython-components/action.yml create mode 100644 .github/actions/ghpython-components/componentize.py create mode 100644 .github/workflows/gh_build.yml create mode 100644 src/gh/components/xml_exporter/code.py create mode 100644 src/gh/components/xml_exporter/icon.png create mode 100644 src/gh/components/xml_exporter/metadata.json rename src/gh/{ => diffCheck}/README.md (100%) delete mode 100644 src/gh/diffCheck/__pycache__/__init__.cpython-38.pyc delete mode 100644 src/gh/diffCheck/__pycache__/geometries.cpython-38.pyc rename src/gh/diffCheck/{ => diffCheck}/__init__.py (100%) rename src/gh/diffCheck/{ => diffCheck}/df_geometries.py (100%) rename src/gh/diffCheck/{ => diffCheck}/diffCheck_app.py (100%) rename src/gh/diffCheck/{ => diffCheck}/joint_detector.py (100%) create mode 100644 src/gh/diffCheck/setup.py diff --git a/.github/actions/ghpython-components/README.md b/.github/actions/ghpython-components/README.md new file mode 100644 index 00000000..ae5089b1 --- /dev/null +++ b/.github/actions/ghpython-components/README.md @@ -0,0 +1 @@ +This action was implemented from the [compass componentizer](https://github.com/compas-dev/compas-actions.ghpython_components/tree/main). We retain no credit for the code, and only modified it to work with our own repository. \ No newline at end of file diff --git a/.github/actions/ghpython-components/action.yml b/.github/actions/ghpython-components/action.yml new file mode 100644 index 00000000..2649c0a9 --- /dev/null +++ b/.github/actions/ghpython-components/action.yml @@ -0,0 +1,32 @@ +# This action was implemented from the [compass componentizer](https://github.com/compas-dev/compas-actions.ghpython_components/tree/main). We retain no credit for the code, and only modified it to work with our own repository. + +name: 'Grasshopper componentizer' +description: 'Create GHUser components from Python source code' +inputs: + source: + description: 'Source directory where code for all components is stored' + required: true + target: + description: 'Target directory for ghuser files' + required: true + prefix: + description: 'Add this prefix to the name of each generated component' + required: false +runs: + using: 'composite' + steps: + - run: nuget install Grasshopper -OutputDirectory ./lib -source https://api.nuget.org/v3/index.json + shell: pwsh + - run: | + $command="ipy" + $params="${{ github.action_path }}/componentize.py", "${{ inputs.source }}", "${{ inputs.target }}", "--ghio", "./lib" + $prefix="${{ inputs.prefix }}" + if( $prefix ) + { + $params=$params + "--prefix", "$prefix" + } + & $command $params + shell: pwsh +branding: + icon: 'box' + color: 'orange' diff --git a/.github/actions/ghpython-components/componentize.py b/.github/actions/ghpython-components/componentize.py new file mode 100644 index 00000000..d737904e --- /dev/null +++ b/.github/actions/ghpython-components/componentize.py @@ -0,0 +1,396 @@ +from __future__ import print_function + +import argparse +import base64 +import json +import os +import re +import sys +import tempfile +import urllib +import zipfile +import StringIO + +import clr +import System +import System.IO + +GHPYTHON_SCRIPT_GUID = System.Guid("410755b1-224a-4c1e-a407-bf32fb45ea7e") +TEMPLATE_VER = re.compile("{{version}}") +TEMPLATE_NAME = re.compile("{{name}}") +TEMPLATE_GHUSER_NAME = re.compile("{{ghuser_name}}") + +TYPES_MAP = dict( + none="35915213-5534-4277-81b8-1bdc9e7383d2", + ghdoc="87f87f55-5b71-41f4-8aea-21d494016f81", + float="39fbc626-7a01-46ab-a18e-ec1c0c41685b", + bool="d60527f5-b5af-4ef6-8970-5f96fe412559", + int="48d01794-d3d8-4aef-990e-127168822244", + complex="309690df-6229-4774-91bb-b1c9c0bfa54d", + str="37261734-eec7-4f50-b6a8-b8d1f3c4396b", + datetime="09bcf900-fe83-4efa-8d32-33d89f7a3e66", + guid="5325b8e1-51d7-4d36-837a-d98394626c35", + color="24b1d1a3-ab79-498c-9e44-c5b14607c4d3", + point="e1937b56-b1da-4c12-8bd8-e34ee81746ef", + vector="15a50725-e3d3-4075-9f7c-142ba5f40747", + plane="3897522d-58e9-4d60-b38c-978ddacfedd8", + interval="589748aa-e558-4dd9-976f-78e3ab91fc77", + uvinterval="74c906f3-db02-4cea-bd58-de375cb5ae73", + box="f29cb021-de79-4e63-9f04-fc8e0df5f8b6", + transform="c4b38e4c-21ff-415f-a0d1-406d282428dd", + line="f802a8cd-e699-4a94-97ea-83b5406271de", + circle="3c5409a1-3293-4181-a6fa-c24c37fc0c32", + arc="9c80ec18-b48c-41b0-bc6e-cd93d9c916aa", + polyline="66fa617b-e3e8-4480-9f1e-2c0688c1d21b", + rectangle="83da014b-a550-4bf5-89ff-16e54225bd5d", + curve="9ba89ec2-5315-435f-a621-b66c5fa2f301", + mesh="794a1f9d-21d5-4379-b987-9e8bbf433912", + surface="f4070a37-c822-410f-9057-100d2e22a22d", + subd="20f4ca9c-6c90-4fd6-ba8a-5bf9ca79db08", + brep="2ceb0405-fdfe-403d-a4d6-8786da45fb9d", + geometrybase="c37956f4-d39c-49c7-af71-1e87f8031b26", +) + +EXPOSURE = dict(valid=set([-1, 2, 4, 8, 16, 32, 64, 128]), default=2) +ACCESS = dict(valid=set([0, 1, 2]), map=dict(item=0, list=1, tree=2), default=0) +PARAM_TYPE = dict( + valid=set(TYPES_MAP.values()), map=TYPES_MAP, default=TYPES_MAP["ghdoc"] +) +WIRE_DISPLAY = dict( + valid=set([0, 1, 2]), map=dict(default=0, faint=1, hidden=2), default=0 +) + + +def fetch_ghio_lib(target_folder="temp"): + """Fetch the GH_IO.dll library from the NuGet packaging system.""" + ghio_dll = "GH_IO.dll" + filename = "lib/net48/" + ghio_dll + + response = urllib.urlopen("https://www.nuget.org/api/v2/package/Grasshopper/") + dst_file = os.path.join(target_folder, ghio_dll) + zip_file = zipfile.ZipFile(StringIO.StringIO(response.read())) + + with zip_file.open(filename, "r") as zipped_dll: + with open(dst_file, "wb") as fp: + fp.write(zipped_dll.read()) + + return dst_file + + +def find_ghio_assembly(libdir): + for root, _dirs, files in os.walk(libdir): + for basename in files: + if basename.upper() == "GH_IO.DLL": + filename = os.path.join(root, basename) + return filename + + +def bitmap_from_image_path(image_path): + with open(image_path, "rb") as imageFile: + img_string = base64.b64encode(imageFile.read()) + return System.Convert.FromBase64String(img_string) + + +def validate_source_bundle(source): + icon = os.path.join(source, "icon.png") + code = os.path.join(source, "code.py") + data = os.path.join(source, "metadata.json") + + if not os.path.exists(icon): + raise ValueError( + "icon missing, make sure icon.png is present in the source bundle: {}".format( + source + ) + ) + if not os.path.exists(code): + raise ValueError( + "code missing, make sure code.py is present in the source bundle: {}".format( + source + ) + ) + if not os.path.exists(data): + raise ValueError( + "metadata missing, make sure metadata.json is present in the source bundle: {}".format( + source + ) + ) + + icon = bitmap_from_image_path(icon) + + with open(code, "r") as f: + python_code = f.read() + + with open(data, "r") as f: + data = json.load(f) + + if "exposure" not in data: + data["exposure"] = EXPOSURE["default"] + + if data["exposure"] not in EXPOSURE["valid"]: + raise ValueError( + "Invalid exposure value. Accepted values are {}".format( + sorted(EXPOSURE["valid"]) + ) + ) + + ghpython = data.get("ghpython") + sdk_mode = ghpython and ghpython.get("isAdvancedMode", False) + + if r'"""' not in python_code and sdk_mode is False: + python_code = r'"""{}"""{}{}'.format( + data.get("description", "Generated by Componentizer"), + os.linesep, + python_code, + ) + + return icon, python_code, data + + +def parse_param_access(access): + try: + access = int(access) + except ValueError: + # Maybe string? + access = ACCESS["map"].get(access) + + if access not in ACCESS["valid"]: + raise ValueError( + "Invalid param access value. Valid values are {}".format( + sorted(ACCESS["valid"]) + ) + ) + + return access + + +def parse_wire_display(wire_display): + try: + wire_display = int(wire_display) + except ValueError: + wire_display = WIRE_DISPLAY["map"].get(wire_display) + + if wire_display not in WIRE_DISPLAY["valid"]: + raise ValueError( + "Invalid wire display value. Valid values are {}".format( + sorted(WIRE_DISPLAY["valid"]) + ) + ) + + return wire_display + + +def parse_param_type_hint(type_hint_id): + type_hint_id = type_hint_id or PARAM_TYPE["default"] + + if type_hint_id in TYPES_MAP: + type_hint_id = TYPES_MAP[type_hint_id] + + if type_hint_id not in PARAM_TYPE["valid"]: + raise ValueError( + 'Invalid param type hint ID ("{}"). Valid values are {}'.format( + type_hint_id, sorted(PARAM_TYPE["valid"]) + ) + ) + + try: + type_hint_id = System.Guid.Parse(type_hint_id) + except SystemError: + raise ValueError("Unable to parse type hint ID: {}".format(type_hint_id)) + + return type_hint_id + + +def replace_templates(code, version, name, ghuser_name): + if version: + code = TEMPLATE_VER.sub(version, code) + + code = TEMPLATE_NAME.sub(name, code) + code = TEMPLATE_GHUSER_NAME.sub(ghuser_name, code) + + return code + + +def create_ghuser_component(source, target, version=None, prefix=None): + from GH_IO.Serialization import GH_LooseChunk + + icon, code, data = validate_source_bundle(source) + + code = replace_templates(code, version, data["name"], os.path.basename(target)) + + instance_guid = data.get("instanceGuid") + if not instance_guid: + instance_guid = System.Guid.NewGuid() + else: + instance_guid = System.Guid.Parse(instance_guid) + + prefix = prefix or "" + + root = GH_LooseChunk("UserObject") + + root.SetGuid("BaseID", GHPYTHON_SCRIPT_GUID) + root.SetString("Name", prefix + data["name"]) + root.SetString("NickName", data["nickname"]) + root.SetString("Description", data.get("description", "")) + root.SetInt32("Exposure", data.get("exposure", EXPOSURE["default"])) + root.SetString("Category", data["category"]) + root.SetString("SubCategory", data["subcategory"]) + root.SetGuid("InstanceGuid", instance_guid) + root.SetByteArray("Icon", icon) + + ghpython_data = data["ghpython"] + ghpython_root = GH_LooseChunk("UserObject") + ghpython_root.SetString("Description", data.get("description", "")) + ghpython_root.SetBoolean("HideOutput", ghpython_data.get("hideOutput", True)) + ghpython_root.SetBoolean("HideInput", ghpython_data.get("hideInput", True)) + ghpython_root.SetBoolean( + "IsAdvancedMode", ghpython_data.get("isAdvancedMode", False) + ) + ghpython_root.SetInt32("IconDisplay", ghpython_data.get("iconDisplay", 0)) + ghpython_root.SetString("Name", data["name"]) + ghpython_root.SetString("NickName", data["nickname"]) + ghpython_root.SetBoolean( + "MarshalOutGuids", ghpython_data.get("marshalOutGuids", True) + ) + ghpython_root.SetString("CodeInput", code) + + # ghpython_root.CreateChunk('Attributes') + # for mf in ('Bounds', 'Pivot', 'Selected'): + params = ghpython_root.CreateChunk("ParameterData") + inputParam = ghpython_data.get("inputParameters", []) + outputParam = ghpython_data.get("outputParameters", []) + + params.SetInt32("InputCount", len(inputParam)) + for i, _pi in enumerate(inputParam): + params.SetGuid( + "InputId", i, System.Guid.Parse("84fa917c-1ed8-4db3-8be1-7bdc4a6495a2") + ) + params.SetInt32("OutputCount", len(outputParam)) + for i, _po in enumerate(outputParam): + params.SetGuid( + "OutputId", i, System.Guid.Parse("8ec86459-bf01-4409-baee-174d0d2b13d0") + ) + + for i, pi in enumerate(inputParam): + input_instance_guid = System.Guid.NewGuid() + pi_chunk = params.CreateChunk("InputParam", i) + pi_chunk.SetString("Name", pi["name"]) + pi_chunk.SetString("NickName", pi.get("nickname") or pi["name"]) + pi_chunk.SetString("Description", pi.get("description")) + pi_chunk.SetBoolean("Optional", pi.get("optional", True)) + pi_chunk.SetBoolean("AllowTreeAccess", pi.get("allowTreeAccess", True)) + pi_chunk.SetBoolean("ShowTypeHints", pi.get("showTypeHints", True)) + pi_chunk.SetInt32( + "ScriptParamAccess", + parse_param_access(pi.get("scriptParamAccess", ACCESS["default"])), + ) + pi_chunk.SetInt32("SourceCount", 0) + pi_chunk.SetGuid("InstanceGuid", input_instance_guid) + pi_chunk.SetGuid("TypeHintID", parse_param_type_hint(pi.get("typeHintID"))) + pi_chunk.SetInt32( + "WireDisplay", + parse_wire_display(pi.get("wireDisplay", WIRE_DISPLAY["default"])), + ) + pi_chunk.SetBoolean("ReverseData", pi.get("reverse", False)) + pi_chunk.SetBoolean("SimplifyData", pi.get("simplify", False)) + # Mutually exclusive options + if pi.get("flatten", False): + pi_chunk.SetInt32("Mapping", 1) + elif pi.get("graft", False): + pi_chunk.SetInt32("Mapping", 2) + + for i, po in enumerate(outputParam): + output_instance_guid = System.Guid.NewGuid() + po_chunk = params.CreateChunk("OutputParam", i) + po_chunk.SetString("Name", po["name"]) + po_chunk.SetString("NickName", po.get("nickname") or po["name"]) + po_chunk.SetString("Description", po.get("description")) + po_chunk.SetBoolean("Optional", po.get("optional", False)) + po_chunk.SetInt32("SourceCount", 0) + po_chunk.SetGuid("InstanceGuid", output_instance_guid) + po_chunk.SetBoolean("ReverseData", po.get("reverse", False)) + po_chunk.SetBoolean("SimplifyData", po.get("simplify", False)) + # Mutually exclusive options + if po.get("flatten", False): + po_chunk.SetInt32("Mapping", 1) + elif po.get("graft", False): + po_chunk.SetInt32("Mapping", 2) + + # print(ghpython_root.Serialize_Xml()) + root.SetByteArray("Object", ghpython_root.Serialize_Binary()) + + System.IO.File.WriteAllBytes(target, root.Serialize_Binary()) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Create GHUser components out of python code." + ) + parser.add_argument( + "source", + type=str, + help="Source directory where code for all components is stored", + ) + parser.add_argument("target", type=str, help="Target directory for ghuser files") + parser.add_argument( + "--ghio", + type=str, + required=False, + help="Folder where the GH_IO.dll assembly is located. Defaults to ./lib", + ) + parser.add_argument( + "--version", type=str, required=False, help="Version to tag components" + ) + parser.add_argument( + "--prefix", + type=str, + required=False, + help="Add this prefix to the name of each generated component", + ) + args = parser.parse_args() + + sourcedir = args.source + if not os.path.isabs(sourcedir): + sourcedir = os.path.abspath(sourcedir) + + targetdir = args.target + if not os.path.isabs(targetdir): + targetdir = os.path.abspath(targetdir) + + if args.ghio is None: + libdir = tempfile.mkdtemp("ghio") + fetch_ghio_lib(libdir) + else: + libdir = os.path.abspath(args.ghio) + gh_io = find_ghio_assembly(libdir) + source_bundles = [ + d + for d in os.listdir(sourcedir) + if os.path.isdir(os.path.join(sourcedir, d)) + and d not in ("__pycache__", ".git") + ] + + print("GHPython componentizer") + print("======================") + + print("[x] Source: {} ({} components)".format(sourcedir, len(source_bundles))) + print("[ ] Target: {}\r".format(targetdir), end="") + if not os.path.exists(targetdir): + os.mkdir(targetdir) + print("[x]") + + print("[ ] GH_IO assembly: {}\r".format(gh_io or args.ghio), end="") + if not gh_io: + print("[-]") + print(" Cannot find GH_IO Assembly! Aborting.") + sys.exit(-1) + clr.AddReferenceToFileAndPath(gh_io) + print("[x]") + print() + + print("Processing component bundles:") + for d in source_bundles: + source = os.path.join(sourcedir, d) + target = os.path.join(targetdir, d + ".ghuser") + print(" [ ] {}\r".format(d), end="") + create_ghuser_component(source, target, args.version, args.prefix) + print(" [x] {} => {}".format(d, target)) \ No newline at end of file diff --git a/.github/workflows/gh_build.yml b/.github/workflows/gh_build.yml new file mode 100644 index 00000000..968ddddf --- /dev/null +++ b/.github/workflows/gh_build.yml @@ -0,0 +1,38 @@ +name: build-components + +on: + push: + branches: ["main"] + pull_request: + branches: ["main"] + +jobs: + build_ghuser_components: + runs-on: windows-latest + name: Build components + steps: + - uses: actions/checkout@v2 + - uses: NuGet/setup-nuget@v1.0.5 + + - name: Install IronPython + run: | + choco install ironpython --version=2.7.8.1 + - uses: ./.github/actions/ghpython-components + with: + source: ./src/gh/components + target: build + # upload them as artifacts: + - uses: actions/upload-artifact@v2 + with: + name: ghuser-components + path: build + + build_release_on_tag: + needs: build_ghuser_components + runs-on: windows-latest + name: Build release + if: startsWith(github.ref, 'refs/tags/v') + steps: + - uses: actions/checkout@v2 + - uses: NuGet/setup-nuget@v1.0.5 + diff --git a/README.md b/README.md index f759f948..de5fb3b4 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,7 @@ # diffCheck

+

diff --git a/src/gh/components/xml_exporter/code.py b/src/gh/components/xml_exporter/code.py new file mode 100644 index 00000000..62c3567b --- /dev/null +++ b/src/gh/components/xml_exporter/code.py @@ -0,0 +1,49 @@ +#! python3 +# requirements: diffcheck +""" +This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them to XML. + +:param i_breps: list of breps +:param i_export_dir: directory to export the xml +:param i_dump: press to dump the xml +""" +import Rhino +import Rhino.Geometry as rg + +import typing + +from ghpythonlib.componentbase import executingcomponent as component + +from diffCheck.df_geometries.df_geometries import DFBeam, DFAssembly + + +class XMLExporter(component): + def RunScript(self, + i_dump : bool, + i_export_dir : str, + i_breps : typing.List[Rhino.Geometry.Brep] + ): + """ + Main function to test the package + :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, "Assembly1") + print(assembly1.beams) + print(assembly1) + + # dump the xml + xml : str = assembly1.to_xml() + if i_dump: + assembly1.dump(xml, i_export_dir) + o_xml = xml + + return o_xml \ No newline at end of file diff --git a/src/gh/components/xml_exporter/icon.png b/src/gh/components/xml_exporter/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..c9e0b54e8008a1a82afe3a6643e7b31733369308 GIT binary patch literal 5660 zcmeHLc~}$I79W=fiXiv|wG?#>xKN#BX0lI{0)|MUMkz)Vwd!PM5=KcTBm)WfK(wE@ zprX~5y40!#o{B3Kty|Srr3zN9T9>+@;*<6X+RAgO+q($}*yUNj@AduhK9iYb=H7FE z_xyhMoHO^E+3~~T0{lY#AP5T3>tYkYe>czB&IkNfxzzU|sP%(P<7hsCbisB9XJ%6v zn9r~?Fym&;5ad2zTQKCk>VE#Y_m;2DpSWj%qN7h|O#b1uV}a>A`+w>faj|5!u5eJW0@7m*yPWq$a1J0oWAV+s<@1-KBHRg zKYa8?r%2t+?4@VtWnXSv8r>l{pftMoTfIW)}N{@-7zDiB&pO~ zp`5a!z?7D1u&ubL-t7)(ACMQ;qf_rmR|KC)HdJ5jJvg%L3(Jh_bIyhMmDTO8*tn}m zee3h`@psQ}&RQy)ydxtoaZK%nqH9lTc1+11pQ*0dmq^ra4)2+L;O+Uu=F_=_tG*o6 z<1N$Tx4B7OzvZs`o~l`WDDRZ9epzT?U0`R)rq0VMp}C9xI_qIam*KMvVm{quo&PZy6{T9d7-dvm+%)X$In%d|ID zGsJ6`Rn?OT#*Rb3wDh_5u6)9_xMk!2GWC46e^!g{<755-k6K|*J3k6sMz0IFFsGV> zpjIVj27Qcy_R;y1eNAISFK`ol!W z_cMK_7R{59MR7#%-(+?oAac2i&flwa{>^Q{1eB3BDEG zE05$3R_Vh=8t45qV|j(&4dm-dMTf@Rs}}ip-Fn^s4BN5SG;PGf>Fr*VrmSq;0UIMt z7+T0i)m`byKZy@uKef0ZBegvu7ho|hj-VwcBI3%}Pm%Vi0mUg>8J|Vw8 z?aA1cQ%=`zD9b0m}=4l`1jlPM)Fhqg+mLIHg&}Jebc2FY(xKj&~dEQQlL@t+0=n@M#hed=bl}Ztci*OtP z7Kk&$#*=Qu<_z~hG+@LsPRhaBd6u)m9!%22rSWQk0QAGp{Il8(h9-EMvrz@0hsaIZ zMVJs3S*@a$Bb>Z89e^}C^qV7`Mo`>E35=6Vb5M*now4!ZEg|CchWI7~4RX^s@H4NZxd6vhfboxnfrIeU9D$8*kP&fYZaIR~4%y~J9&#IxpRm7g2q z>G_p8@bkB4cqW<`8(0|(L@Y<8dA!xfK8ppKqga|~a)ywiCJHxGCPayf&4^egp%Dc} zV~ELwkxDscRxnCg3qZZi$&)sU@c@D;ge(9fJi-(<}>j2xGu7I-9rJv^Gg44??mBu_TMNeC1iaw8@tq*6kR^+)lRaDWhN z&UlfvC*@%km>$HNj&<^!Bg5O&PzOdZsSS4xw<)Z*0Kl*}l?jq+AWV5_(q2yiT01EdMX$(eZ<>0n|kKwq^W##3qG_-DBa;~)ObmkY#sASS+VL&}^EFk}hF)1Z!6G`C+F2kh=$w(B4Ng|^Wv%*X=m{evq$&}AK z{bI&A+^;b|evdEa2{cq;#3Y17-WX;71F~|Z)GRdtief3FL_n5`K`8;n38Q2*O)@4* zqM-h7$VyQ$E=4H{kTo%gL@rh$BxxoQQi@YjTuRAEvY`{o1f*VO7yENZZK%^Fb4tO&;~XMV9z0H+H^E#0`T?E{4`dNKXVEgel^KU z>HA8qS8~0S0xxC!D!N|D^->DFl<}+R`mf35*ZkUov4Op<3%rz29+%GrFEo5iL*in+ zuQs3unq5=DReQTG$q7NiaL?JwT@;lL8hv@aLF-%7*0+Pa=kTv@bpcI%^|3KVU3u-% zm{t(luI)NOMmi#?O*wZmdJ4xBjs E-^)b$v;Y7A literal 0 HcmV?d00001 diff --git a/src/gh/components/xml_exporter/metadata.json b/src/gh/components/xml_exporter/metadata.json new file mode 100644 index 00000000..71af459d --- /dev/null +++ b/src/gh/components/xml_exporter/metadata.json @@ -0,0 +1,68 @@ +{ + "name": "Exporter to xml", + "nickname": "XMLout", + "category": "Utilities", + "subcategory": "ALL", + "description": "This component reads breps, convert them to DFBeams and DFAssemblies and export it to XML.", + "exposure": 4, + "instanceGuid": "cdae4bd5-d18e-4b06-9367-791b6b1f6837", + "ghpython": { + "hideOutput": true, + "hideInput": true, + "isAdvancedMode": true, + "marshalOutGuids": true, + "iconDisplay": 2, + "inputParameters": [ + { + "name": "i_dump", + "nickname": "i_dump", + "description": "Press button to export xml", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "bool", + "simplify": false + }, + { + "name": "i_export_dir", + "nickname": "i_export_dir", + "description": "The directors where to export the xml file.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "str", + "flatten": true + }, + { + "name": "i_breps", + "nickname": "i_breps", + "description": "The breps of the structure.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "list", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "brep", + "reverse": true, + "simplify": false + } + ], + "outputParameters": [ + { + "name": "o_xml", + "nickname": "o_xml", + "description": "The string of xml to be exported.", + "optional": false, + "sourceCount": 0, + "graft": false + } + ] + } +} \ No newline at end of file diff --git a/src/gh/README.md b/src/gh/diffCheck/README.md similarity index 100% rename from src/gh/README.md rename to src/gh/diffCheck/README.md diff --git a/src/gh/diffCheck/__pycache__/__init__.cpython-38.pyc b/src/gh/diffCheck/__pycache__/__init__.cpython-38.pyc deleted file mode 100644 index b13b9668f30d902921d6542f97d0f3a2062467b5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 132 zcmWIL<>g`kf|eb8X(0MBh(HF6K#l_t7qb9~6oz01O-8?!3`HPe1o2BV%_=4(GcCZHyC#P({H&;S2U)myoA>b~T<` zT3VA;nU~mAP`vRRsB(Do58%(}m8bj#p7_4jXm;(Lb$EzWeRTSI&gpZ$)2*A`ZYc2l z`)_AP|7r>GA6AY(9x7K+vV9OGl$?mE97svtnK%Q-e%*nq1g@=ep>%zkoE+lVwXKc`}?NS=Jx2>G9bEDE(lIzT_RLW0Ed05I~ zD4}Bgkatk7p=57@JQ8EE2$XyzV)Alv&hn^_oke7MY%?@<`g<5|pJ%S2YfOX02YDt- zFVmCJGhyh_|GquixvSFA=-R#>KDe8i;oZIcV-0(HKGnHNb#`%aSa#!hG0*Ziouzpk zZ(@GNHHGZpEzVWjbMd)BCrsi5YtpM=sPtHTh8Uqi__{RaGx1L!W_bM~td`t~ZogM} z+tD3M2k)6C=9++nMpUE?t_e5Y3IzWS->ZW*jH8**s73bUw=60 zW5!$jRFU^AZRGyb=I3G@prvJ@fEeoBoKYJU(dI9>%f%b-S9VMfvOL;P9_lE`qlr#X zyR@>T7n-kQaOqC;%)CM_yp>E2^v{i%8}kh`3|euT#n!UYJ2*&H*&w}Ky0Eo$VePsY zwNVpcdbR;V>}((|I!;IWvN%g6zXUiq(G=w!EF_*`r!DmvQ{5kODu zL_ODk}K)?$7)=rxNvdE(TzGl{fV|7HY{(-S@ zuh*)S_9k>R&)l+g14Amve+zZShHdAGYqRi?l^J_K!>B9;w-iK%0SM= z0P@y$W!?)2rxEMGV2`a|Qo$PGOQpUH;YVmQ5!e3SX#yDkzeZWX%?e0Wzt>%dH}g6d zBHqj!B;O|?5RMRLe!%LfxcVV_-$k)oUgIig6IF(Nrz7eHdS67;xS@TVw76*EUKrqO zPuv#}<*VQyQt@Ky4cfY++NklY^#)zF0fcRq!TVXJr}rm^#pRcwY!>0}YR54w@580b zt6{_PHY`toh@P_`Vm2X&5c>Se#TJi+7&l$$;Pi{F`UtF*={aT_bE=bI%{|KQ`5lbN zczYB$pNd!NxnEV_hV_C~@G?4HJf5tM>(t}%bdTySgZE6m7L=<37(WFbw{B=h&27iq??3DGp-vgo%U{GuD%^OU;07}mAL9B(moBr}bN=Tt^bG-Hr!ooNJNsuCGZudp z4{+~)B>(PwjH`fE8Yl1t4DC6kbMc+ZmUmFE46?R_yUcpS`E+qbaZv)@$CibncyqPA zMo;GtwKe(T?qohpCfOA*^+ZUa&+0Av$x4EiWyQ3QEit4VyCL{{SSO?3+gO_`jxq#+ zU1g2e$*oRf^J7+Rj=oH8-9h{|I(~<;N*KI|1zzB8xQ2bb02k`|$5Lm8npVllo&xk* jm7%N>oUu+!8SGa77gspn9{M=!CDYQ@7RqZV=N - 178 - -118 + 86 + 0 - 1.5 + 1.2750002 @@ -115,7 +115,7 @@ true 2 - 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 + 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 dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 true @@ -612,7 +612,7 @@ Panel false - 0.10945549979805946 + 0.42412034049630165 bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e 1 Double click to edit panel content… @@ -654,32 +654,29 @@ - 3ede854e-c753-40eb-84cb-b48008f14fd4 - Text + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button - - Contains a collection of text fragments - bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e - Text - Txt + + Button object with two values + False + True + 5de6f2a8-d2d0-49e6-92b4-ae1ed47ccbfd + Button + dump! false - f5d7e77d-04d1-4395-b52b-651450a4b329 - 1 + 0 - + - 345 - 158 - 50 - 24 - - - 370.98038 - 170.96075 + 68 + 127 + 102 + 22 @@ -689,29 +686,32 @@ - a8b97322-2d53-47cd-905e-b932c3ccd74e - Button + 3ede854e-c753-40eb-84cb-b48008f14fd4 + Text - - Button object with two values - False - True - 5de6f2a8-d2d0-49e6-92b4-ae1ed47ccbfd - Button - dump! + + Contains a collection of text fragments + bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e + Text + Txt false - 0 + f5d7e77d-04d1-4395-b52b-651450a4b329 + 1 - + - 68 - 127 - 102 - 22 + 348 + 186 + 50 + 24 + + + 373.8549 + 198.45097 @@ -726,7 +726,7 @@ - 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 + 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 From 44748b2f8afe1eb352bf16ac042c2a11a1778e26 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 14:23:41 +0200 Subject: [PATCH 014/141] WIP: testing componentizer action x2 --- .github/workflows/{gh_build.yml => gh-build.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename .github/workflows/{gh_build.yml => gh-build.yml} (100%) diff --git a/.github/workflows/gh_build.yml b/.github/workflows/gh-build.yml similarity index 100% rename from .github/workflows/gh_build.yml rename to .github/workflows/gh-build.yml From 4ccb8cc392d41c309e1faca0bcd5d2cca4840cb5 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 16:44:51 +0200 Subject: [PATCH 015/141] WIP: testing action componentizer --- .../actions/ghpython-components/action.yml | 28 ++- .github/workflows/gh-build.yml | 3 +- deps/eigen | 2 +- src/gh/tester.ghx | 210 +++++++++++++++++- 4 files changed, 227 insertions(+), 16 deletions(-) diff --git a/.github/actions/ghpython-components/action.yml b/.github/actions/ghpython-components/action.yml index 2649c0a9..2ca66836 100644 --- a/.github/actions/ghpython-components/action.yml +++ b/.github/actions/ghpython-components/action.yml @@ -1,5 +1,3 @@ -# This action was implemented from the [compass componentizer](https://github.com/compas-dev/compas-actions.ghpython_components/tree/main). We retain no credit for the code, and only modified it to work with our own repository. - name: 'Grasshopper componentizer' description: 'Create GHUser components from Python source code' inputs: @@ -12,15 +10,29 @@ inputs: prefix: description: 'Add this prefix to the name of each generated component' required: false + interpreter: + description: 'Python interpreter to use: ironpython, or cpython' + required: false + default: 'ironpython' + runs: using: 'composite' steps: - - run: nuget install Grasshopper -OutputDirectory ./lib -source https://api.nuget.org/v3/index.json + - name: Install Grasshopper + run: nuget install Grasshopper -OutputDirectory ./lib -source https://api.nuget.org/v3/index.json shell: pwsh - - run: | - $command="ipy" - $params="${{ github.action_path }}/componentize.py", "${{ inputs.source }}", "${{ inputs.target }}", "--ghio", "./lib" - $prefix="${{ inputs.prefix }}" + + - name: Launch componentizer + run: | + if ("${{ inputs.interpreter }}" -eq "cpython") { + $command="python" + $componentizer="${{ github.action_path }}/componentize_cpy.py" + } else { + $command="ipy" + $componentizer="${{ github.action_path }}/componentize_ipy.py" + } + $params=$componentizer, "${{ inputs.source }}", "${{ inputs.target }}", "--ghio", "./lib" + $prefix="${{ inputs.prefix }}" if( $prefix ) { $params=$params + "--prefix", "$prefix" @@ -29,4 +41,4 @@ runs: shell: pwsh branding: icon: 'box' - color: 'orange' + color: 'orange' \ No newline at end of file diff --git a/.github/workflows/gh-build.yml b/.github/workflows/gh-build.yml index 968ddddf..a7bc1265 100644 --- a/.github/workflows/gh-build.yml +++ b/.github/workflows/gh-build.yml @@ -1,4 +1,4 @@ -name: build-components +name: gh-build on: push: @@ -21,6 +21,7 @@ jobs: with: source: ./src/gh/components target: build + interpreter: cpython # upload them as artifacts: - uses: actions/upload-artifact@v2 with: diff --git a/deps/eigen b/deps/eigen index b2c9ba2b..2620cb93 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit b2c9ba2beef4b5fd61513d73911c678e93c8dd9d +Subproject commit 2620cb930b7ad87ed1d77a26319739f4b1c86d33 diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index 67f0ee4f..ccd49548 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 86 - 0 + 82 + -295 - 1.2750002 + 1.5 @@ -99,9 +99,9 @@ - 8 + 9 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -719,6 +719,204 @@ + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + Script + + + + + Scripting component + true + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQsSURBVEhL3ZRdTFtlHMbxwmTGxCjRVKOyOTZ0Ywx6TnvaDhBhE8VlrjF6a/TCJToKo7AxvsYKGC8WY/RmoR+0Y4WOQVkZ5WN8tuLYF+LGiFSdK8zdaRzzI8Toex7/7zmnEC5rTEx8kn/aJu/7e58+53lPyn8q4WBblt7mcusPOmN6m/vn7DL3Xzk27496uz8m2jucUmXXc9rS5CWUOvMJfC+n1N2aXeZZFg75IBw6BQJDrAzAcKQbhsozfwi1wae0Lckpx+Zq5u75d6HM5xHtfoL7YTh8VoXTGGtCMBwNNSobkpXe5nFSJCv6slNhfUXnSsK1sToI49FzNL2Qavsh1Yf92pbkJNh8VUL56YhQ2UkToDkbMVb3RMTDPX9y51IdwRuG6ICh5A4Q7a2PG+xtzxrsgfVTd04ZsSb0k1Q/ABPBTY0jkBzjfnnJms6WrG55cd8Reb44VUOtl77U9Ya+rO2KUNEOsSpAc4by7oKhukeNpKaP3A4qYKmBPgludkxAapr0y3etFtzeB3xbAszvWcZc3mMaVhV3LNg8vwkVp9WGcLDyIDmcZ31egw+rzo+PEXxSOcDUHPXI3+/NR+xV4OZuYLYA8uVdtRpaFVXQrTpONITA/GFy1zzr1UhGVedNEViao7C0TMHUMlUix4rfx40iYOZF4JIFLCpOa2hVYmXH9VXXSkt6YeSuE3Fw5wQ3Hx8n+GQCvGJpnnLdmX4zlc0W3sbVPGDaDEQMYBey7gEpD2h4iqiq63cVTFnX8qwHYGwYXDQ1Xjjw9qf+Qm9fy1veMJ+P1KHf8xffKWI393yM2fxlXMkFpiRgQgBGdgLh7YB34wYNT/+guvsHxbEWh6E2vFL0YZ+OmnGC5hfcsUKZpf3Arb1Q8p6jvL9UI8HnRmBcDwxnAf0vgAW3fKehVYnVoTGpLqxmTRmbjo14sGTNWwXzWXydWvIa8HUxcL0QuJavRhIl+Gg2MLQD6Hse6EkHAmk+Da3KVD9QnniIZmqIyTFWQs4/W4XHqYLfKBUEvnoJSt4XCT4pqpEMZgKhDKB7M9CZBrldt0NDqzJXdD1kPDZ8VznAMQ6LY2I3W9rvVOCJSKiC7FqBzC7lyiwiyWxMkNnQTpmd3y6zYIbMAptk1v7MguzRvath10tqHHzE5Jj4wNwUbc9tmspkcTqAw3kkVEF2Ne9Xbem/I7bwihPzL6uR8LwpEhYR42w0K87CmXHWtzXOutPjrCPtE21LcmJzRU5+K5UKfmFay7t/G1hvxn3WtdnFOp6+z3y6f/Y2lWcK3sPlXVRB6vc49XuIV3Ab0LsVLLDRydcw75MuuTW1XNmQrDBZsIFFDQsYy1mrYHALryCYj5y7dS52MvWGfEL3sLYleWFGfJBu5QEWyhhg3ZtuUSQrFEmMOZ8IyycfLYU3Ze22/k+VkvI34q8RvMUeXlAAAAAASUVORK5CYII= + + 68e93733-269e-4deb-85f9-f55554589eb9 + true + true + true + Script + S + + false + false + true + + + + + + 142 + 298 + 72 + 44 + + + 171 + 320 + + + + + + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 2 + 3ede854e-c753-40eb-84cb-b48008f14fd4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + No conversion + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 2b845980-88f2-4f63-a0f7-1574827539c1 + x + x + true + 0 + true + 0 + + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 144 + 300 + 12 + 20 + + + 151.5 + 310 + + + + + + + + true + No conversion + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 5bcdf1ec-3568-4e90-b700-efefc0113dc5 + y + y + true + 0 + true + 0 + + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 144 + 320 + 12 + 20 + + + 151.5 + 330 + + + + + + + + The execution information, as output and error streams + 9c06c502-948b-4734-bfa1-5b29e4707c6f + out + out + false + 0 + + + + + + 186 + 300 + 26 + 20 + + + 199 + 310 + + + + + + + + false + No conversion + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 85f65616-883d-4997-93fa-54d4e44e80e2 + a + a + false + 0 + true + 0 + + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 186 + 320 + 26 + 20 + + + 199 + 330 + + + + + + + + + + IiIiR3Jhc3Nob3BwZXIgU2NyaXB0IiIiDQphID0gIkhlbGxvIFB5dGhvbiAzIGluIEdyYXNzaG9wcGVyISINCnByaW50KGEpDQo= + S + + + + + mcneel.pythonnet.python + 3.9.10 + + + + + + + + @@ -726,7 +924,7 @@ - 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 + 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 From 27c2dd6e2721871f73a6746ac9156ee52a8dd73f Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 16:47:46 +0200 Subject: [PATCH 016/141] WIP: using default compas action --- .github/actions/ghpython-components/README.md | 1 - .../actions/ghpython-components/action.yml | 44 -- .../ghpython-components/componentize.py | 396 ------------------ .github/workflows/gh-build.yml | 24 +- 4 files changed, 8 insertions(+), 457 deletions(-) delete mode 100644 .github/actions/ghpython-components/README.md delete mode 100644 .github/actions/ghpython-components/action.yml delete mode 100644 .github/actions/ghpython-components/componentize.py diff --git a/.github/actions/ghpython-components/README.md b/.github/actions/ghpython-components/README.md deleted file mode 100644 index ae5089b1..00000000 --- a/.github/actions/ghpython-components/README.md +++ /dev/null @@ -1 +0,0 @@ -This action was implemented from the [compass componentizer](https://github.com/compas-dev/compas-actions.ghpython_components/tree/main). We retain no credit for the code, and only modified it to work with our own repository. \ No newline at end of file diff --git a/.github/actions/ghpython-components/action.yml b/.github/actions/ghpython-components/action.yml deleted file mode 100644 index 2ca66836..00000000 --- a/.github/actions/ghpython-components/action.yml +++ /dev/null @@ -1,44 +0,0 @@ -name: 'Grasshopper componentizer' -description: 'Create GHUser components from Python source code' -inputs: - source: - description: 'Source directory where code for all components is stored' - required: true - target: - description: 'Target directory for ghuser files' - required: true - prefix: - description: 'Add this prefix to the name of each generated component' - required: false - interpreter: - description: 'Python interpreter to use: ironpython, or cpython' - required: false - default: 'ironpython' - -runs: - using: 'composite' - steps: - - name: Install Grasshopper - run: nuget install Grasshopper -OutputDirectory ./lib -source https://api.nuget.org/v3/index.json - shell: pwsh - - - name: Launch componentizer - run: | - if ("${{ inputs.interpreter }}" -eq "cpython") { - $command="python" - $componentizer="${{ github.action_path }}/componentize_cpy.py" - } else { - $command="ipy" - $componentizer="${{ github.action_path }}/componentize_ipy.py" - } - $params=$componentizer, "${{ inputs.source }}", "${{ inputs.target }}", "--ghio", "./lib" - $prefix="${{ inputs.prefix }}" - if( $prefix ) - { - $params=$params + "--prefix", "$prefix" - } - & $command $params - shell: pwsh -branding: - icon: 'box' - color: 'orange' \ No newline at end of file diff --git a/.github/actions/ghpython-components/componentize.py b/.github/actions/ghpython-components/componentize.py deleted file mode 100644 index d737904e..00000000 --- a/.github/actions/ghpython-components/componentize.py +++ /dev/null @@ -1,396 +0,0 @@ -from __future__ import print_function - -import argparse -import base64 -import json -import os -import re -import sys -import tempfile -import urllib -import zipfile -import StringIO - -import clr -import System -import System.IO - -GHPYTHON_SCRIPT_GUID = System.Guid("410755b1-224a-4c1e-a407-bf32fb45ea7e") -TEMPLATE_VER = re.compile("{{version}}") -TEMPLATE_NAME = re.compile("{{name}}") -TEMPLATE_GHUSER_NAME = re.compile("{{ghuser_name}}") - -TYPES_MAP = dict( - none="35915213-5534-4277-81b8-1bdc9e7383d2", - ghdoc="87f87f55-5b71-41f4-8aea-21d494016f81", - float="39fbc626-7a01-46ab-a18e-ec1c0c41685b", - bool="d60527f5-b5af-4ef6-8970-5f96fe412559", - int="48d01794-d3d8-4aef-990e-127168822244", - complex="309690df-6229-4774-91bb-b1c9c0bfa54d", - str="37261734-eec7-4f50-b6a8-b8d1f3c4396b", - datetime="09bcf900-fe83-4efa-8d32-33d89f7a3e66", - guid="5325b8e1-51d7-4d36-837a-d98394626c35", - color="24b1d1a3-ab79-498c-9e44-c5b14607c4d3", - point="e1937b56-b1da-4c12-8bd8-e34ee81746ef", - vector="15a50725-e3d3-4075-9f7c-142ba5f40747", - plane="3897522d-58e9-4d60-b38c-978ddacfedd8", - interval="589748aa-e558-4dd9-976f-78e3ab91fc77", - uvinterval="74c906f3-db02-4cea-bd58-de375cb5ae73", - box="f29cb021-de79-4e63-9f04-fc8e0df5f8b6", - transform="c4b38e4c-21ff-415f-a0d1-406d282428dd", - line="f802a8cd-e699-4a94-97ea-83b5406271de", - circle="3c5409a1-3293-4181-a6fa-c24c37fc0c32", - arc="9c80ec18-b48c-41b0-bc6e-cd93d9c916aa", - polyline="66fa617b-e3e8-4480-9f1e-2c0688c1d21b", - rectangle="83da014b-a550-4bf5-89ff-16e54225bd5d", - curve="9ba89ec2-5315-435f-a621-b66c5fa2f301", - mesh="794a1f9d-21d5-4379-b987-9e8bbf433912", - surface="f4070a37-c822-410f-9057-100d2e22a22d", - subd="20f4ca9c-6c90-4fd6-ba8a-5bf9ca79db08", - brep="2ceb0405-fdfe-403d-a4d6-8786da45fb9d", - geometrybase="c37956f4-d39c-49c7-af71-1e87f8031b26", -) - -EXPOSURE = dict(valid=set([-1, 2, 4, 8, 16, 32, 64, 128]), default=2) -ACCESS = dict(valid=set([0, 1, 2]), map=dict(item=0, list=1, tree=2), default=0) -PARAM_TYPE = dict( - valid=set(TYPES_MAP.values()), map=TYPES_MAP, default=TYPES_MAP["ghdoc"] -) -WIRE_DISPLAY = dict( - valid=set([0, 1, 2]), map=dict(default=0, faint=1, hidden=2), default=0 -) - - -def fetch_ghio_lib(target_folder="temp"): - """Fetch the GH_IO.dll library from the NuGet packaging system.""" - ghio_dll = "GH_IO.dll" - filename = "lib/net48/" + ghio_dll - - response = urllib.urlopen("https://www.nuget.org/api/v2/package/Grasshopper/") - dst_file = os.path.join(target_folder, ghio_dll) - zip_file = zipfile.ZipFile(StringIO.StringIO(response.read())) - - with zip_file.open(filename, "r") as zipped_dll: - with open(dst_file, "wb") as fp: - fp.write(zipped_dll.read()) - - return dst_file - - -def find_ghio_assembly(libdir): - for root, _dirs, files in os.walk(libdir): - for basename in files: - if basename.upper() == "GH_IO.DLL": - filename = os.path.join(root, basename) - return filename - - -def bitmap_from_image_path(image_path): - with open(image_path, "rb") as imageFile: - img_string = base64.b64encode(imageFile.read()) - return System.Convert.FromBase64String(img_string) - - -def validate_source_bundle(source): - icon = os.path.join(source, "icon.png") - code = os.path.join(source, "code.py") - data = os.path.join(source, "metadata.json") - - if not os.path.exists(icon): - raise ValueError( - "icon missing, make sure icon.png is present in the source bundle: {}".format( - source - ) - ) - if not os.path.exists(code): - raise ValueError( - "code missing, make sure code.py is present in the source bundle: {}".format( - source - ) - ) - if not os.path.exists(data): - raise ValueError( - "metadata missing, make sure metadata.json is present in the source bundle: {}".format( - source - ) - ) - - icon = bitmap_from_image_path(icon) - - with open(code, "r") as f: - python_code = f.read() - - with open(data, "r") as f: - data = json.load(f) - - if "exposure" not in data: - data["exposure"] = EXPOSURE["default"] - - if data["exposure"] not in EXPOSURE["valid"]: - raise ValueError( - "Invalid exposure value. Accepted values are {}".format( - sorted(EXPOSURE["valid"]) - ) - ) - - ghpython = data.get("ghpython") - sdk_mode = ghpython and ghpython.get("isAdvancedMode", False) - - if r'"""' not in python_code and sdk_mode is False: - python_code = r'"""{}"""{}{}'.format( - data.get("description", "Generated by Componentizer"), - os.linesep, - python_code, - ) - - return icon, python_code, data - - -def parse_param_access(access): - try: - access = int(access) - except ValueError: - # Maybe string? - access = ACCESS["map"].get(access) - - if access not in ACCESS["valid"]: - raise ValueError( - "Invalid param access value. Valid values are {}".format( - sorted(ACCESS["valid"]) - ) - ) - - return access - - -def parse_wire_display(wire_display): - try: - wire_display = int(wire_display) - except ValueError: - wire_display = WIRE_DISPLAY["map"].get(wire_display) - - if wire_display not in WIRE_DISPLAY["valid"]: - raise ValueError( - "Invalid wire display value. Valid values are {}".format( - sorted(WIRE_DISPLAY["valid"]) - ) - ) - - return wire_display - - -def parse_param_type_hint(type_hint_id): - type_hint_id = type_hint_id or PARAM_TYPE["default"] - - if type_hint_id in TYPES_MAP: - type_hint_id = TYPES_MAP[type_hint_id] - - if type_hint_id not in PARAM_TYPE["valid"]: - raise ValueError( - 'Invalid param type hint ID ("{}"). Valid values are {}'.format( - type_hint_id, sorted(PARAM_TYPE["valid"]) - ) - ) - - try: - type_hint_id = System.Guid.Parse(type_hint_id) - except SystemError: - raise ValueError("Unable to parse type hint ID: {}".format(type_hint_id)) - - return type_hint_id - - -def replace_templates(code, version, name, ghuser_name): - if version: - code = TEMPLATE_VER.sub(version, code) - - code = TEMPLATE_NAME.sub(name, code) - code = TEMPLATE_GHUSER_NAME.sub(ghuser_name, code) - - return code - - -def create_ghuser_component(source, target, version=None, prefix=None): - from GH_IO.Serialization import GH_LooseChunk - - icon, code, data = validate_source_bundle(source) - - code = replace_templates(code, version, data["name"], os.path.basename(target)) - - instance_guid = data.get("instanceGuid") - if not instance_guid: - instance_guid = System.Guid.NewGuid() - else: - instance_guid = System.Guid.Parse(instance_guid) - - prefix = prefix or "" - - root = GH_LooseChunk("UserObject") - - root.SetGuid("BaseID", GHPYTHON_SCRIPT_GUID) - root.SetString("Name", prefix + data["name"]) - root.SetString("NickName", data["nickname"]) - root.SetString("Description", data.get("description", "")) - root.SetInt32("Exposure", data.get("exposure", EXPOSURE["default"])) - root.SetString("Category", data["category"]) - root.SetString("SubCategory", data["subcategory"]) - root.SetGuid("InstanceGuid", instance_guid) - root.SetByteArray("Icon", icon) - - ghpython_data = data["ghpython"] - ghpython_root = GH_LooseChunk("UserObject") - ghpython_root.SetString("Description", data.get("description", "")) - ghpython_root.SetBoolean("HideOutput", ghpython_data.get("hideOutput", True)) - ghpython_root.SetBoolean("HideInput", ghpython_data.get("hideInput", True)) - ghpython_root.SetBoolean( - "IsAdvancedMode", ghpython_data.get("isAdvancedMode", False) - ) - ghpython_root.SetInt32("IconDisplay", ghpython_data.get("iconDisplay", 0)) - ghpython_root.SetString("Name", data["name"]) - ghpython_root.SetString("NickName", data["nickname"]) - ghpython_root.SetBoolean( - "MarshalOutGuids", ghpython_data.get("marshalOutGuids", True) - ) - ghpython_root.SetString("CodeInput", code) - - # ghpython_root.CreateChunk('Attributes') - # for mf in ('Bounds', 'Pivot', 'Selected'): - params = ghpython_root.CreateChunk("ParameterData") - inputParam = ghpython_data.get("inputParameters", []) - outputParam = ghpython_data.get("outputParameters", []) - - params.SetInt32("InputCount", len(inputParam)) - for i, _pi in enumerate(inputParam): - params.SetGuid( - "InputId", i, System.Guid.Parse("84fa917c-1ed8-4db3-8be1-7bdc4a6495a2") - ) - params.SetInt32("OutputCount", len(outputParam)) - for i, _po in enumerate(outputParam): - params.SetGuid( - "OutputId", i, System.Guid.Parse("8ec86459-bf01-4409-baee-174d0d2b13d0") - ) - - for i, pi in enumerate(inputParam): - input_instance_guid = System.Guid.NewGuid() - pi_chunk = params.CreateChunk("InputParam", i) - pi_chunk.SetString("Name", pi["name"]) - pi_chunk.SetString("NickName", pi.get("nickname") or pi["name"]) - pi_chunk.SetString("Description", pi.get("description")) - pi_chunk.SetBoolean("Optional", pi.get("optional", True)) - pi_chunk.SetBoolean("AllowTreeAccess", pi.get("allowTreeAccess", True)) - pi_chunk.SetBoolean("ShowTypeHints", pi.get("showTypeHints", True)) - pi_chunk.SetInt32( - "ScriptParamAccess", - parse_param_access(pi.get("scriptParamAccess", ACCESS["default"])), - ) - pi_chunk.SetInt32("SourceCount", 0) - pi_chunk.SetGuid("InstanceGuid", input_instance_guid) - pi_chunk.SetGuid("TypeHintID", parse_param_type_hint(pi.get("typeHintID"))) - pi_chunk.SetInt32( - "WireDisplay", - parse_wire_display(pi.get("wireDisplay", WIRE_DISPLAY["default"])), - ) - pi_chunk.SetBoolean("ReverseData", pi.get("reverse", False)) - pi_chunk.SetBoolean("SimplifyData", pi.get("simplify", False)) - # Mutually exclusive options - if pi.get("flatten", False): - pi_chunk.SetInt32("Mapping", 1) - elif pi.get("graft", False): - pi_chunk.SetInt32("Mapping", 2) - - for i, po in enumerate(outputParam): - output_instance_guid = System.Guid.NewGuid() - po_chunk = params.CreateChunk("OutputParam", i) - po_chunk.SetString("Name", po["name"]) - po_chunk.SetString("NickName", po.get("nickname") or po["name"]) - po_chunk.SetString("Description", po.get("description")) - po_chunk.SetBoolean("Optional", po.get("optional", False)) - po_chunk.SetInt32("SourceCount", 0) - po_chunk.SetGuid("InstanceGuid", output_instance_guid) - po_chunk.SetBoolean("ReverseData", po.get("reverse", False)) - po_chunk.SetBoolean("SimplifyData", po.get("simplify", False)) - # Mutually exclusive options - if po.get("flatten", False): - po_chunk.SetInt32("Mapping", 1) - elif po.get("graft", False): - po_chunk.SetInt32("Mapping", 2) - - # print(ghpython_root.Serialize_Xml()) - root.SetByteArray("Object", ghpython_root.Serialize_Binary()) - - System.IO.File.WriteAllBytes(target, root.Serialize_Binary()) - - -if __name__ == "__main__": - parser = argparse.ArgumentParser( - description="Create GHUser components out of python code." - ) - parser.add_argument( - "source", - type=str, - help="Source directory where code for all components is stored", - ) - parser.add_argument("target", type=str, help="Target directory for ghuser files") - parser.add_argument( - "--ghio", - type=str, - required=False, - help="Folder where the GH_IO.dll assembly is located. Defaults to ./lib", - ) - parser.add_argument( - "--version", type=str, required=False, help="Version to tag components" - ) - parser.add_argument( - "--prefix", - type=str, - required=False, - help="Add this prefix to the name of each generated component", - ) - args = parser.parse_args() - - sourcedir = args.source - if not os.path.isabs(sourcedir): - sourcedir = os.path.abspath(sourcedir) - - targetdir = args.target - if not os.path.isabs(targetdir): - targetdir = os.path.abspath(targetdir) - - if args.ghio is None: - libdir = tempfile.mkdtemp("ghio") - fetch_ghio_lib(libdir) - else: - libdir = os.path.abspath(args.ghio) - gh_io = find_ghio_assembly(libdir) - source_bundles = [ - d - for d in os.listdir(sourcedir) - if os.path.isdir(os.path.join(sourcedir, d)) - and d not in ("__pycache__", ".git") - ] - - print("GHPython componentizer") - print("======================") - - print("[x] Source: {} ({} components)".format(sourcedir, len(source_bundles))) - print("[ ] Target: {}\r".format(targetdir), end="") - if not os.path.exists(targetdir): - os.mkdir(targetdir) - print("[x]") - - print("[ ] GH_IO assembly: {}\r".format(gh_io or args.ghio), end="") - if not gh_io: - print("[-]") - print(" Cannot find GH_IO Assembly! Aborting.") - sys.exit(-1) - clr.AddReferenceToFileAndPath(gh_io) - print("[x]") - print() - - print("Processing component bundles:") - for d in source_bundles: - source = os.path.join(sourcedir, d) - target = os.path.join(targetdir, d + ".ghuser") - print(" [ ] {}\r".format(d), end="") - create_ghuser_component(source, target, args.version, args.prefix) - print(" [x] {} => {}".format(d, target)) \ No newline at end of file diff --git a/.github/workflows/gh-build.yml b/.github/workflows/gh-build.yml index a7bc1265..06259397 100644 --- a/.github/workflows/gh-build.yml +++ b/.github/workflows/gh-build.yml @@ -14,26 +14,18 @@ jobs: - uses: actions/checkout@v2 - uses: NuGet/setup-nuget@v1.0.5 - - name: Install IronPython + - name: Install CPython and pythonnet package run: | - choco install ironpython --version=2.7.8.1 - - uses: ./.github/actions/ghpython-components + choco install python --version=3.9.10 + python -m pip install pythonnet==3.0.3 + + - uses: compas-dev/compas-actions.ghpython_components@v5 with: - source: ./src/gh/components + source: components target: build interpreter: cpython - # upload them as artifacts: + - uses: actions/upload-artifact@v2 with: name: ghuser-components - path: build - - build_release_on_tag: - needs: build_ghuser_components - runs-on: windows-latest - name: Build release - if: startsWith(github.ref, 'refs/tags/v') - steps: - - uses: actions/checkout@v2 - - uses: NuGet/setup-nuget@v1.0.5 - + path: build \ No newline at end of file From f9535a2d8afd7014b69438752d7e6e1b0cb3f393 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 16:48:27 +0200 Subject: [PATCH 017/141] WIP: using default compas action x2 --- .github/workflows/gh-build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/gh-build.yml b/.github/workflows/gh-build.yml index 06259397..c26103ff 100644 --- a/.github/workflows/gh-build.yml +++ b/.github/workflows/gh-build.yml @@ -21,7 +21,7 @@ jobs: - uses: compas-dev/compas-actions.ghpython_components@v5 with: - source: components + source: src/gh/components target: build interpreter: cpython From c3e7ee45d4d15d4ea2b885c96e6700edc518af36 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 20:53:02 +0200 Subject: [PATCH 018/141] FIX-CAP: component fixed + componentizer --- CONTRIBUTING.md | 30 ++ src/gh/components/xml_exporter/code.py | 9 +- src/gh/components/xml_exporter/metadata.json | 2 - src/gh/diffCheck/README.md | 6 +- src/gh/diffCheck/diffCheck/__init__.py | 1 + src/gh/diffCheck/setup.py | 34 +- src/gh/util/componentizer_cpy.py | 408 +++++++++++++++++++ 7 files changed, 466 insertions(+), 24 deletions(-) create mode 100644 src/gh/util/componentizer_cpy.py diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 0e9e1d38..c24de844 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -48,6 +48,36 @@ git add .gitmodules git commit -m "Remove a submodule name" ``` +--- +# PyPI +To push the package to PyPI, you need to: +1. Install the package `twine`: +```bash +pip install twine +``` +2. Build the package: +```bash +python setup.py sdist bdist_wheel +``` +3. Check the package: +```bash +twine check dist/* +``` +4. Upload the package: +```bash +twine upload dist/* +``` +Be sure to have the right to upload the package to the PyPI repository. +To do so you need to set the `~/.pypirc` file with the following content: +```bash +[distutils] +index-servers=pypi + +[pypi] + username = __token__ + password = pypi- +``` + --- # C++ diff --git a/src/gh/components/xml_exporter/code.py b/src/gh/components/xml_exporter/code.py index 62c3567b..69be3030 100644 --- a/src/gh/components/xml_exporter/code.py +++ b/src/gh/components/xml_exporter/code.py @@ -1,5 +1,5 @@ #! python3 -# requirements: diffcheck +# requirements: diffCheck """ This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them to XML. @@ -7,14 +7,15 @@ :param i_export_dir: directory to export the xml :param i_dump: press to dump the xml """ +import System +import typing + import Rhino import Rhino.Geometry as rg -import typing - from ghpythonlib.componentbase import executingcomponent as component -from diffCheck.df_geometries.df_geometries import DFBeam, DFAssembly +from diffCheck.df_geometries import DFBeam, DFAssembly class XMLExporter(component): diff --git a/src/gh/components/xml_exporter/metadata.json b/src/gh/components/xml_exporter/metadata.json index 71af459d..de14ce2e 100644 --- a/src/gh/components/xml_exporter/metadata.json +++ b/src/gh/components/xml_exporter/metadata.json @@ -37,7 +37,6 @@ "wireDisplay": "default", "sourceCount": 0, "typeHintID": "str", - "flatten": true }, { "name": "i_breps", @@ -50,7 +49,6 @@ "wireDisplay": "default", "sourceCount": 0, "typeHintID": "brep", - "reverse": true, "simplify": false } ], diff --git a/src/gh/diffCheck/README.md b/src/gh/diffCheck/README.md index e94c5323..afa64734 100644 --- a/src/gh/diffCheck/README.md +++ b/src/gh/diffCheck/README.md @@ -1 +1,5 @@ -This directory contains all the code for the grasshopper plugin of DiffCheck written in CPython. \ No newline at end of file +# DiffCheck Grasshopper Plugin + +DiffCheck is a plugin for Rhino/Grasshopper that allows the user to compare a 3D model with its scan. + +More information to come \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/__init__.py b/src/gh/diffCheck/diffCheck/__init__.py index e69de29b..210ebb3e 100644 --- a/src/gh/diffCheck/diffCheck/__init__.py +++ b/src/gh/diffCheck/diffCheck/__init__.py @@ -0,0 +1 @@ +__version__ = '0.0.2' \ No newline at end of file diff --git a/src/gh/diffCheck/setup.py b/src/gh/diffCheck/setup.py index c7276fc7..3a3a225e 100644 --- a/src/gh/diffCheck/setup.py +++ b/src/gh/diffCheck/setup.py @@ -1,18 +1,18 @@ -# from setuptools import setup, find_packages +from setuptools import setup, find_packages -# setup( -# name='mypackage', -# version='0.1', -# packages=find_packages(), -# description='A sample Python package', -# long_description=open('README.md').read(), -# long_description_content_type='text/markdown', -# author='Your Name', -# author_email='your.email@example.com', -# url='https://github.com/yourusername/mypackage', -# classifiers=[ -# 'License :: OSI Approved :: MIT License', -# 'Programming Language :: Python :: 3', -# 'Programming Language :: Python :: 3.7', -# ], -# ) \ No newline at end of file +setup( + name='diffCheck', + version='0.0.2', + packages=find_packages(), + description='DiffCheck is a package to check the differences between two timber structures', + long_description=open('README.md').read(), + long_description_content_type='text/markdown', + author='Andrea Settimi, Damien Gilliard, Eleni Skevaki, Marirena Kladeftira, Julien Gamerro, Stefana Parascho, and Yves Weinand', + author_email='andrea.settimi@epfl.ch', + url='https://github.com/diffCheckOrg/diffCheck', + classifiers=[ + 'License :: OSI Approved :: MIT License', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.7', + ], +) \ No newline at end of file diff --git a/src/gh/util/componentizer_cpy.py b/src/gh/util/componentizer_cpy.py new file mode 100644 index 00000000..cdffe828 --- /dev/null +++ b/src/gh/util/componentizer_cpy.py @@ -0,0 +1,408 @@ +import argparse +import base64 +import json +import os +import re +import sys +import tempfile +import urllib.request, urllib.parse, urllib.error +import zipfile +from io import BytesIO + +import clr +import System +import System.IO + + +SCRIPT_COMPONENT_GUID = System.Guid("c9b2d725-6f87-4b07-af90-bd9aefef68eb") +CPY_VER = "3.-1" +TEMPLATE_VER = re.compile("{{version}}") +TEMPLATE_NAME = re.compile("{{name}}") +TEMPLATE_GHUSER_NAME = re.compile("{{ghuser_name}}") + +TYPES_MAP = dict( + none="6a184b65-baa3-42d1-a548-3915b401de53", + ghdoc="1c282eeb-dd16-439f-94e4-7d92b542fe8b", + float="9d51e32e-c038-4352-9554-f4137ca91b9a", + bool="d60527f5-b5af-4ef6-8970-5f96fe412559", + int="48d01794-d3d8-4aef-990e-127168822244", + complex="309690df-6229-4774-91bb-b1c9c0bfa54d", + str="3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88", + datetime="09bcf900-fe83-4efa-8d32-33d89f7a3e66", + guid="5325b8e1-51d7-4d36-837a-d98394626c35", + color="24b1d1a3-ab79-498c-9e44-c5b14607c4d3", + point="e1937b56-b1da-4c12-8bd8-e34ee81746ef", + vector="15a50725-e3d3-4075-9f7c-142ba5f40747", + plane="3897522d-58e9-4d60-b38c-978ddacfedd8", + interval="589748aa-e558-4dd9-976f-78e3ab91fc77", + uvinterval="74c906f3-db02-4cea-bd58-de375cb5ae73", + box="f29cb021-de79-4e63-9f04-fc8e0df5f8b6", + transform="c4b38e4c-21ff-415f-a0d1-406d282428dd", + line="f802a8cd-e699-4a94-97ea-83b5406271de", + circle="3c5409a1-3293-4181-a6fa-c24c37fc0c32", + arc="9c80ec18-b48c-41b0-bc6e-cd93d9c916aa", + polyline="66fa617b-e3e8-4480-9f1e-2c0688c1d21b", + rectangle="83da014b-a550-4bf5-89ff-16e54225bd5d", + curve="9ba89ec2-5315-435f-a621-b66c5fa2f301", + mesh="794a1f9d-21d5-4379-b987-9e8bbf433912", + surface="f4070a37-c822-410f-9057-100d2e22a22d", + subd="20f4ca9c-6c90-4fd6-ba8a-5bf9ca79db08", + brep="2ceb0405-fdfe-403d-a4d6-8786da45fb9d", + geometrybase="c37956f4-d39c-49c7-af71-1e87f8031b26" +) + +EXPOSURE = dict(valid=set([-1, 2, 4, 8, 16, 32, 64, 128]), default=2) +ACCESS = dict(valid=set([0, 1, 2]), map=dict(item=0, list=1, tree=2), default=0) +PARAM_TYPE = dict( + valid=set(TYPES_MAP.values()), map=TYPES_MAP, default=TYPES_MAP["ghdoc"] +) +WIRE_DISPLAY = dict( + valid=set([0, 1, 2]), map=dict(default=0, faint=1, hidden=2), default=0 +) + + +def fetch_ghio_lib(target_folder="temp"): + """Fetch the GH_IO.dll library from the NuGet packaging system.""" + ghio_dll = "GH_IO.dll" + filename = "lib/net48/" + ghio_dll + + response = urllib.request.urlopen("https://www.nuget.org/api/v2/package/Grasshopper/") + dst_file = os.path.join(target_folder, ghio_dll) + zip_file = zipfile.ZipFile(BytesIO(response.read())) + + with zip_file.open(filename, "r") as zipped_dll: + with open(dst_file, "wb") as fp: + fp.write(zipped_dll.read()) + + return dst_file + + +def find_ghio_assembly(libdir): + for root, _dirs, files in os.walk(libdir): + for basename in files: + if basename.upper() == "GH_IO.DLL": + filename = os.path.join(root, basename) + return filename + + +def bitmap_from_image_path(image_path): + with open(image_path, "rb") as imageFile: + # Ensure img_string is a string, not a bytes object + img_string = base64.b64encode(imageFile.read()) + if isinstance(img_string, bytes): + img_string = img_string.decode() + + # Now you can pass img_string to the FromBase64String method + return System.Convert.FromBase64String(img_string) + # return System.Convert.FromBase64String(img_string) + + +def validate_source_bundle(source): + icon = os.path.join(source, "icon.png") + code = os.path.join(source, "code.py") + data = os.path.join(source, "metadata.json") + + if not os.path.exists(icon): + raise ValueError( + "icon missing, make sure icon.png is present in the source bundle: {}".format( + source + ) + ) + if not os.path.exists(code): + raise ValueError( + "code missing, make sure code.py is present in the source bundle: {}".format( + source + ) + ) + if not os.path.exists(data): + raise ValueError( + "metadata missing, make sure metadata.json is present in the source bundle: {}".format( + source + ) + ) + + icon = bitmap_from_image_path(icon) + + with open(code, "r") as f: + python_code = f.read() + + with open(data, "r") as f: + data = json.load(f) + + if "exposure" not in data: + data["exposure"] = EXPOSURE["default"] + + if data["exposure"] not in EXPOSURE["valid"]: + raise ValueError( + "Invalid exposure value. Accepted values are {}".format( + sorted(EXPOSURE["valid"]) + ) + ) + + ghpython = data.get("ghpython") + + if r'"""' not in python_code: + python_code = r'"""{}"""{}{}'.format( + data.get("description", "Generated by Componentizer"), + os.linesep, + python_code, + ) + + return icon, python_code, data + + +def parse_param_access(access): + try: + access = int(access) + except ValueError: + # Maybe string? + access = ACCESS["map"].get(access) + + if access not in ACCESS["valid"]: + raise ValueError( + "Invalid param access value. Valid values are {}".format( + sorted(ACCESS["valid"]) + ) + ) + + return access + + +def parse_wire_display(wire_display): + try: + wire_display = int(wire_display) + except ValueError: + wire_display = WIRE_DISPLAY["map"].get(wire_display) + + if wire_display not in WIRE_DISPLAY["valid"]: + raise ValueError( + "Invalid wire display value. Valid values are {}".format( + sorted(WIRE_DISPLAY["valid"]) + ) + ) + + return wire_display + + +def parse_param_type_hint(type_hint_id): + type_hint_id = type_hint_id or PARAM_TYPE["default"] + + if type_hint_id in TYPES_MAP: + type_hint_id = TYPES_MAP[type_hint_id] + + if type_hint_id not in PARAM_TYPE["valid"]: + raise ValueError( + 'Invalid param type hint ID ("{}"). Valid values are {}'.format( + type_hint_id, sorted(PARAM_TYPE["valid"]) + ) + ) + + try: + type_hint_id = System.Guid.Parse(type_hint_id) + except SystemError: + raise ValueError("Unable to parse type hint ID: {}".format(type_hint_id)) + + return type_hint_id + + +def replace_templates(code, version, name, ghuser_name): + if version: + code = TEMPLATE_VER.sub(version, code) + + code = TEMPLATE_NAME.sub(name, code) + code = TEMPLATE_GHUSER_NAME.sub(ghuser_name, code) + + return code + + +def create_ghuser_component(source, target, version=None, prefix=None): + from GH_IO.Serialization import GH_LooseChunk + + icon, code, data = validate_source_bundle(source) + + code = replace_templates(code, version, data["name"], os.path.basename(target)) + + instance_guid = data.get("instanceGuid") + if not instance_guid: + instance_guid = System.Guid.NewGuid() + else: + instance_guid = System.Guid.Parse(instance_guid) + + prefix = prefix or "" + + root = GH_LooseChunk("UserObject") + root.SetGuid("BaseID", SCRIPT_COMPONENT_GUID) + root.SetString("Name", prefix + data["name"]) + root.SetString("NickName", data["nickname"]) + root.SetString("Description", data.get("description", "")) + root.SetString("ToolTip", data.get("description", "")) + root.SetInt32("Exposure", data.get("exposure", EXPOSURE["default"])) + root.SetString("Category", data["category"]) + root.SetString("SubCategory", data["subcategory"]) + root.SetGuid("InstanceGuid", instance_guid) + root.SetByteArray("Icon", icon) + + ghpython_data = data["ghpython"] + + ghpython_root = GH_LooseChunk("UserObject") + ghpython_root.SetString("Description", data.get("description", "")) + bitmap_icon = System.Drawing.Bitmap.FromStream(System.IO.MemoryStream(icon)) + ghpython_root.SetDrawingBitmap("IconOverride", bitmap_icon) + ghpython_root.SetBoolean("UsingLibraryInputParam", False) + ghpython_root.SetBoolean("UsingScriptInputParam", False) + ghpython_root.SetBoolean("UsingStandardOutputParam", False) + ghpython_root.SetInt32("IconDisplay", ghpython_data.get("iconDisplay", 0)) + ghpython_root.SetString("Name", data["name"]) + ghpython_root.SetString("NickName", data["nickname"]) + ghpython_root.SetBoolean("MarshalGuids", ghpython_data.get("marshalGuids", True)) + + # ghpython_root.CreateChunk('Attributes') + # for mf in ('Bounds', 'Pivot', 'Selected'): + + params = ghpython_root.CreateChunk("ParameterData") + inputParam = ghpython_data.get("inputParameters", []) + outputParam = ghpython_data.get("outputParameters", []) + + params.SetInt32("InputCount", len(inputParam)) + for i, _pi in enumerate(inputParam): + params.SetGuid( + "InputId", i, System.Guid.Parse("08908df5-fa14-4982-9ab2-1aa0927566aa") + ) + params.SetInt32("OutputCount", len(outputParam)) + for i, _po in enumerate(outputParam): + params.SetGuid( + "OutputId", i, System.Guid.Parse("08908df5-fa14-4982-9ab2-1aa0927566aa") + ) + + for i, pi in enumerate(inputParam): + input_instance_guid = System.Guid.NewGuid() + pi_chunk = params.CreateChunk("InputParam", i) + pi_chunk.SetString("Name", pi["name"]) + pi_chunk.SetString("NickName", pi.get("nickname") or pi["name"]) + pi_chunk.SetString("Description", pi.get("description")) + pi_chunk.SetBoolean("Optional", pi.get("optional", True)) + pi_chunk.SetString("ToolTip", pi.get("description", "")) + pi_chunk.SetBoolean("AllowTreeAccess", pi.get("allowTreeAccess", True)) + pi_chunk.SetBoolean("ShowTypeHints", pi.get("showTypeHints", True)) + pi_chunk.SetInt32( + "ScriptParamAccess", + parse_param_access(pi.get("scriptParamAccess", ACCESS["default"])), + ) + pi_chunk.SetInt32("SourceCount", pi.get("sourceCount", 0)) + pi_chunk.SetGuid("InstanceGuid", input_instance_guid) + pi_chunk.SetGuid("TypeHintID", parse_param_type_hint(pi.get("typeHintID"))) + pi_chunk.SetInt32( + "WireDisplay", + parse_wire_display(pi.get("wireDisplay", WIRE_DISPLAY["default"])), + ) + pi_chunk.SetBoolean("ReverseData", pi.get("reverse", False)) + pi_chunk.SetBoolean("SimplifyData", pi.get("simplify", False)) + if pi.get("flatten", False): + pi_chunk.SetInt32("Mapping", 1) + elif pi.get("graft", False): + pi_chunk.SetInt32("Mapping", 2) + + for i, po in enumerate(outputParam): + output_instance_guid = System.Guid.NewGuid() + po_chunk = params.CreateChunk("OutputParam", i) + po_chunk.SetString("Name", po["name"]) + po_chunk.SetString("NickName", po.get("nickname") or po["name"]) + po_chunk.SetString("Description", po.get("description")) + po_chunk.SetBoolean("Optional", po.get("optional", False)) + po_chunk.SetString("ToolTip", po.get("description", "")) + po_chunk.SetInt32("SourceCount", po.get("sourceCount", 0)) + po_chunk.SetGuid("InstanceGuid", output_instance_guid) + po_chunk.SetBoolean("ReverseData", po.get("reverse", False)) + po_chunk.SetBoolean("SimplifyData", po.get("simplify", False)) + if po.get("flatten", False): + po_chunk.SetInt32("Mapping", 1) + elif po.get("graft", False): + po_chunk.SetInt32("Mapping", 2) + + script = ghpython_root.CreateChunk("Script") + + code_base64 = base64.b64encode(code.encode("utf-8")) + code_base64 = str(code_base64)[2:-1] + script.SetString("Text", code_base64) + script.SetString("Title", "S") + language_spec = script.CreateChunk("LanguageSpec") + language_spec.SetString("Taxon", "*.*.python") + language_spec.SetString("Version", CPY_VER) + + # xml_serialized = ghpython_root.Serialize_Xml() + root.SetByteArray("Object", ghpython_root.Serialize_Binary()) + System.IO.File.WriteAllBytes(target, root.Serialize_Binary()) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Create GHUser components out of python code." + ) + parser.add_argument( + "source", + type=str, + help="Source directory where code for all components is stored", + ) + parser.add_argument("target", type=str, help="Target directory for ghuser files") + parser.add_argument( + "--ghio", + type=str, + required=False, + help="Folder where the GH_IO.dll assembly is located. Defaults to ./lib", + ) + parser.add_argument( + "--version", type=str, required=False, help="Version to tag components" + ) + parser.add_argument( + "--prefix", + type=str, + required=False, + help="Add this prefix to the name of each generated component", + ) + args = parser.parse_args() + + sourcedir = args.source + if not os.path.isabs(sourcedir): + sourcedir = os.path.abspath(sourcedir) + + targetdir = args.target + if not os.path.isabs(targetdir): + targetdir = os.path.abspath(targetdir) + + if args.ghio is None: + libdir = tempfile.mkdtemp("ghio") + fetch_ghio_lib(libdir) + else: + libdir = os.path.abspath(args.ghio) + gh_io = find_ghio_assembly(libdir) + source_bundles = [ + d + for d in os.listdir(sourcedir) + if os.path.isdir(os.path.join(sourcedir, d)) + and d not in ("__pycache__", ".git") + ] + + print("GHPython componentizer") + print("======================") + + print("[x] Source: {} ({} components)".format(sourcedir, len(source_bundles))) + print("[ ] Target: {}\r".format(targetdir), end="") + if not os.path.exists(targetdir): + os.mkdir(targetdir) + print("[x]") + + if not gh_io: + print("[-] Cannot find GH_IO Assembly! Aborting.") + sys.exit(-1) + + clr.AddReference(os.path.splitext(gh_io)[0]) + + print("[x] GH_IO assembly: {}".format(gh_io)) + + print("Processing component bundles:") + for d in source_bundles: + source = os.path.join(sourcedir, d) + target = os.path.join(targetdir, d + ".ghuser") + print(" [ ] {}\r".format(d), end="") + create_ghuser_component(source, target, args.version, args.prefix) + print(" [x] {} => {}".format(d, target)) \ No newline at end of file From 05afa78ddad8bda65c58a64bfd4d407505198713 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 20:55:41 +0200 Subject: [PATCH 019/141] FIX: correct categories for metadata componentizer --- src/gh/components/xml_exporter/metadata.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/gh/components/xml_exporter/metadata.json b/src/gh/components/xml_exporter/metadata.json index de14ce2e..4d2ba635 100644 --- a/src/gh/components/xml_exporter/metadata.json +++ b/src/gh/components/xml_exporter/metadata.json @@ -1,8 +1,8 @@ { "name": "Exporter to xml", "nickname": "XMLout", - "category": "Utilities", - "subcategory": "ALL", + "category": "diffCheck", + "subcategory": "Utility", "description": "This component reads breps, convert them to DFBeams and DFAssemblies and export it to XML.", "exposure": 4, "instanceGuid": "cdae4bd5-d18e-4b06-9367-791b6b1f6837", From 6ef7bf1b96b310a17a892db660ccc1cb05ac14ff Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 20:58:06 +0200 Subject: [PATCH 020/141] FIX-WIP: solving problem with metadata componentizer --- src/gh/components/xml_exporter/metadata.json | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/gh/components/xml_exporter/metadata.json b/src/gh/components/xml_exporter/metadata.json index 4d2ba635..438b6f20 100644 --- a/src/gh/components/xml_exporter/metadata.json +++ b/src/gh/components/xml_exporter/metadata.json @@ -23,8 +23,7 @@ "scriptParamAccess": "item", "wireDisplay": "default", "sourceCount": 0, - "typeHintID": "bool", - "simplify": false + "typeHintID": "bool" }, { "name": "i_export_dir", @@ -36,7 +35,7 @@ "scriptParamAccess": "item", "wireDisplay": "default", "sourceCount": 0, - "typeHintID": "str", + "typeHintID": "str" }, { "name": "i_breps", @@ -48,8 +47,7 @@ "scriptParamAccess": "list", "wireDisplay": "default", "sourceCount": 0, - "typeHintID": "brep", - "simplify": false + "typeHintID": "brep" } ], "outputParameters": [ From 8068233fca5b80920e3c1be90b5f43ffb064b591 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 7 Apr 2024 22:17:40 +0200 Subject: [PATCH 021/141] ADD: badge to readme for pypi --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index de5fb3b4..5927947b 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,7 @@

+

From 1d72a739d84887ec02efcee12b369872c5e398e9 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 8 Apr 2024 12:10:47 +0200 Subject: [PATCH 022/141] WIP-FLASH: basic reverse transform, working on detection --- src/gh/diffCheck/diffCheck/df_cut.py | 130 +++ src/gh/diffCheck/diffCheck/df_hole.py | 241 +++++ .../diffCheck/diffCheck/df_joint_detector.py | 252 +++++ .../diffCheck/diffCheck/df_transformations.py | 123 +++ src/gh/diffCheck/diffCheck/diffCheck_app.py | 191 +++- src/gh/diffCheck/diffCheck/joint_detector.py | 0 src/gh/tester.ghx | 908 +++++++++++------- 7 files changed, 1494 insertions(+), 351 deletions(-) create mode 100644 src/gh/diffCheck/diffCheck/df_cut.py create mode 100644 src/gh/diffCheck/diffCheck/df_hole.py create mode 100644 src/gh/diffCheck/diffCheck/df_joint_detector.py create mode 100644 src/gh/diffCheck/diffCheck/df_transformations.py delete mode 100644 src/gh/diffCheck/diffCheck/joint_detector.py diff --git a/src/gh/diffCheck/diffCheck/df_cut.py b/src/gh/diffCheck/diffCheck/df_cut.py new file mode 100644 index 00000000..a1793266 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_cut.py @@ -0,0 +1,130 @@ +import Rhino as rc +import Rhino.Geometry as rg +import rhinoscriptsyntax as rs +import scriptcontext as sc + +import log +import util +import acim +import visual_debug as vd + +import random + +def parse_data_from_brep(ACIM, + p_GUID, + cut_b, + bbox_b): + """ + Parse data from a brep defining a cut + :param ACIM: the ACIM object to export xml + :param p_GUID: the guid of the timber + :param box_b: the brep defining the cut + :param bbox_b: the brep of the bounding box + """ + log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") + log.info("Parsing cut data..") + bbox_faces_b = util.explode_brep(bbox_b) + cut_faces_b = util.explode_brep(cut_b) + log.info("Cut faces: " + str(len(cut_faces_b))) + + acim_faces = [] + acim_edges = [] + # template dicts for faces and lines + acim_face_dict = {"face_id" : "1", # the id of the face + "exposed" : "True", # if the face is exposed + "edges" : "1 2 3", # the ids of the lines + "corners" : ["0 0 0", "1 1 1", "2 2 2"] # the coordinates of the corners + } + acim_edge_dict = {"line_id" : "1", # the id of the line + "start" : "0 0 0", # the start point of the line + "end" : "1 1 1", # the end point of the line + "exposed" : "true", # if the line is exposed + } + + # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + log.info("Detecting cut centroid..") + cut_centroid = cut_b.GetBoundingBox(True).Center + cut_centroid_str = str(cut_centroid.X) + " " + str(cut_centroid.Y) + " " + str(cut_centroid.Z) + + # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + log.info("Parsing lines..") + clr_edge = (0,0,0) + face_edges = cut_b.Edges + is_on_face = False + TEMP_line_ids = [] + TEMP_line_midpoints = [] + for i, face_edge in enumerate(face_edges): + acim_edge_dict["line_id"] = str(i) + acim_edge_dict["start"] = str(face_edge.PointAtStart.X) + " " + str(face_edge.PointAtStart.Y) + " " + str(face_edge.PointAtStart.Z) + acim_edge_dict["end"] = str(face_edge.PointAtEnd.X) + " " + str(face_edge.PointAtEnd.Y) + " " + str(face_edge.PointAtEnd.Z) + + face_edge_center = face_edge.PointAtNormalizedLength(0.5) + if bbox_b.IsPointInside(face_edge_center, sc.doc.ModelAbsoluteTolerance, True): + is_on_face = False + clr_edge = (0,255,0) + else: + is_on_face = True + clr_edge = (255,0,0) + acim_edge_dict["exposed"] = str(is_on_face) + + acim_edges.append(acim_edge_dict.copy()) + + vd.addPtName(face_edge.PointAtStart, str(i), clr_edge) + vd.addLine(rg.Line(face_edge.PointAtStart, face_edge.PointAtEnd), clr_edge) + + TEMP_line_ids.append(i) + TEMP_line_midpoints.append(face_edge_center) + + # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + log.info("Parsing faces..") + clr_face = (0,0,0) + for i, face in enumerate(cut_faces_b): + edges_candidate_ids = [] + acim_face_dict["face_id"] = str(i) + + face_edges = face.Edges + is_on_face = False + + # corners + corners = util.compute_ordered_vertices(face) + corners_str = [] + for corner in corners: + corners_str.append(str(corner.X) + " " + str(corner.Y) + " " + str(corner.Z)) + acim_face_dict["corners"] = corners_str + + # edges indices + for i, face_edge in enumerate(face_edges): + face_edge_center = face_edge.PointAtNormalizedLength(0.5) + idx = util.detect_idx_pt_in_list(face_edge_center, TEMP_line_midpoints) + if idx != -1: + edges_candidate_ids.append(TEMP_line_ids[idx]) + vertex = face_edge.PointAtStart + acim_face_dict["edges"] = " ".join(str(x) for x in edges_candidate_ids) + + # face exposed value + polyline_corners = corners + polyline_corners.append(corners[0]) + polyline = rg.Polyline(corners) + # vd.addPolyline(polyline, (0,0,0)) + face_center = polyline.CenterPoint() + # log.info("Face center: " + str(face_center)) + # vd.addBrep(bbox_b, (0,0,0)) + if bbox_b.IsPointInside(face_center, sc.doc.ModelAbsoluteTolerance, True): + is_on_face = False + clr_face = (0,255,0) + else: + is_on_face = True + clr_face = (255,0,0) + vd.addPtName(face_center, acim_face_dict["edges"], clr_face) + acim_face_dict["exposed"] = str(is_on_face) + + acim_faces.append(acim_face_dict.copy()) + + # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + log.info("Dumping cut in acim..") + ACIM.add_cut( + p_GUID, + cut_centroid_str, + acim_edges, + acim_faces + ) diff --git a/src/gh/diffCheck/diffCheck/df_hole.py b/src/gh/diffCheck/diffCheck/df_hole.py new file mode 100644 index 00000000..95f9adc5 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_hole.py @@ -0,0 +1,241 @@ +import Rhino as rc +import Rhino.Geometry as rg +import rhinoscriptsyntax as rs +import scriptcontext as sc +import random + +import log +import acim +import visual_debug as vd +import util + + +def _get_radius_from_curved_brep_faces(cylinder_faces_b, start_pt, end_pt): + for face in cylinder_faces_b: + if not face.Faces[0].IsPlanar(): + face_curves = face.DuplicateEdgeCurves(True) + face_crv = face_curves[0] + pt_base = face_crv.PointAtStart + axis_ln = rg.Line(start_pt, end_pt) + radius = axis_ln.DistanceTo(pt_base, False) + radius = round(radius, 3) + log.info("radius: " + str(radius)) + return round(radius, 3) + +def _get_single_face_brep_center(brep): + bbox = brep.GetBoundingBox(True) + bbox_b = bbox.ToBrep() + center_point = bbox_b.GetBoundingBox(True).Center + return center_point + +def parse_data_from_brep(ACIM, + p_GUID, + cylinder_b, + bbox_b): + """ + Parse data from a brep defining a hole + :param ACIM: the ACIM object to export xml + :param p_GUID: the guid of the timber + :param cylinder_b: the brep defining the hole + :param bbox_b: the brep of the bounding box + """ + log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") + bbox_faces_b = util.explode_brep(bbox_b) + cylinder_faces_b = util.explode_brep(cylinder_b) + log.info("cylinder faces: " + str(len(cylinder_faces_b))) + # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + # get the centers of the cylinder's bases and if they are exposed + acim_centers = {} + for face in cylinder_faces_b: + if face.Faces[0].IsPlanar(): + continue + face_curves = face.DuplicateEdgeCurves(True) + for face_crv in face_curves: + face_crv_center = util.get_crv_circle_center(face_crv) + is_on_face = False + if bbox_b.IsPointInside(face_crv_center, sc.doc.ModelAbsoluteTolerance, True): + if util.is_pt_unique_in_dict(face_crv_center, acim_centers): + acim_centers[face_crv_center] = is_on_face + vd.addPt(face_crv_center, (0,255,0)) + continue + if rs.IsPointOnSurface(face, face_crv_center): + is_on_face = True + if util.is_pt_unique_in_dict(face_crv_center, acim_centers): + acim_centers[face_crv_center] = is_on_face + vd.addPt(face_crv_center, (255,0,0)) + log.info("length of acim_centers: " + str(len(acim_centers))) + + # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + # parse simple holes or sub-holes + centers_len = len(acim_centers) + if centers_len == 0: + log.error("No center found for the hole. Exiting...") + return + if centers_len == 1: + log.info("Single center found for the hole. Exiting...") + return + if centers_len == 2: + log.info("Simple 2-points hole detected") + start_pt = rg.Point3d(0,0,0) + end_pt = rg.Point3d(0,0,0) + is_start_pt_accessible = False + is_end_pt_accessible = False + if acim_centers.values()[0]: + start_pt = acim_centers.keys()[0] + end_pt = acim_centers.keys()[1] + is_start_pt_accessible = acim_centers.values()[0] + is_end_pt_accessible = acim_centers.values()[1] + else: + start_pt = acim_centers.keys()[1] + end_pt = acim_centers.keys()[0] + is_start_pt_accessible = acim_centers.values()[1] + is_end_pt_accessible = acim_centers.values()[0] + + radius = _get_radius_from_curved_brep_faces(cylinder_faces_b, start_pt, end_pt) + log.info("radius: " + str(radius)) + vd.addLine(rg.Line(start_pt, end_pt), (255,165,0)) + vd.addDotPt(ptA=start_pt, ptB=end_pt, clr=(0,255,0), txt=str(ACIM.peek_current_hole_id(p_GUID))) + + for face in cylinder_faces_b: + if not face.Faces[0].IsPlanar(): + face_curves = face.DuplicateEdgeCurves(True) + vd.addCurve(face_curves[0], (255,0,255)) + vd.addCurve(face_curves[1], (255,0,255)) + + ACIM.add_hole(p_GUID, + start_pt, + end_pt, + is_start_pt_accessible, + is_end_pt_accessible, + radius) + if centers_len > 2: + log.info("Complex hole detected") + holes = [] + + # get longest line + dists = [] + extreme_pts = [] + for i in range(0, centers_len): + for j in range(i+1, centers_len): + pt1 = acim_centers.keys()[i] + pt2 = acim_centers.keys()[j] + dist = pt1.DistanceTo(pt2) + dists.append(dist) + if dist >= max(dists) or len(dists) == 0: + extreme_pts = [i, j] + + extreme_pts = [acim_centers.keys()[extreme_pts[0]], + acim_centers.keys()[extreme_pts[1]]] + longest_ln = rg.Line(extreme_pts[0], extreme_pts[1]) + longest_crv = longest_ln.ToNurbsCurve() + + centers_lst_reorder = list(acim_centers.keys()) + centers_lst_reorder.sort(key=lambda x: extreme_pts[0].DistanceTo(x)) + + #create segments + hole_axis_ln = [] + for i in range(0, centers_len-1): + pt1 = centers_lst_reorder[i] + pt2 = centers_lst_reorder[i+1] + ln = rg.Line(pt1, pt2) + hole_axis_ln.append(ln) + + # detect neighbours + neighbor_lst = [] + for i in range(0, len(hole_axis_ln)): + for j in range(0, len(hole_axis_ln)): + if i == j: + continue + if hole_axis_ln[i].DistanceTo(hole_axis_ln[j].From, False) < 0.01: + neighbor_lst.append([i, j]) + break + if hole_axis_ln[i].DistanceTo(hole_axis_ln[j].To, False) < 0.01: + neighbor_lst.append([i, j]) + break + log.info("neighbor pattern for current hole set: " + str(neighbor_lst)) + next_hole_ids = [] + current_hole_id = ACIM.peek_current_hole_id(p_GUID) + for i in range(1, len(neighbor_lst)+1): + next_hole_ids.append(current_hole_id) + current_hole_id += 1 + log.info("next hole ids: " + str(next_hole_ids)) + neighbor_acim_str = [] + for i in range(0, len(neighbor_lst)): + temp_str = "" + for j in range(1, len(neighbor_lst[i])): + temp_str += str(next_hole_ids[neighbor_lst[i][j]]) + " " + temp_str = temp_str[:-1] + neighbor_acim_str.append(temp_str) + log.info("neighbor acim str: " + str(neighbor_acim_str)) + + for i, axis_ln in enumerate(hole_axis_ln): + vd.addLine(axis_ln, (255,165,0)) + vd.addDotLn(ln=axis_ln, clr=(30,255,230), txt=str(ACIM.peek_current_hole_id(p_GUID))) + + start_pt = rg.Point3d(0,0,0) + end_pt = rg.Point3d(0,0,0) + is_start_pt_accessible = False + is_end_pt_accessible = False + pt_1 = axis_ln.PointAt(0) + pt_2 = axis_ln.PointAt(1) + if acim_centers[pt_1]: + start_pt = pt_1 + end_pt = pt_2 + is_start_pt_accessible = acim_centers[pt_1] + is_end_pt_accessible = acim_centers[pt_2] + else: + start_pt = pt_2 + end_pt = pt_1 + is_start_pt_accessible = acim_centers[pt_2] + is_end_pt_accessible = acim_centers[pt_1] + + for face in cylinder_faces_b: + if not face.Faces[0].IsPlanar(): + radius = 0 + face_curves = face.DuplicateEdgeCurves(True) + face_center_A = util.get_crv_circle_center(face_curves[0]) + face_center_B = util.get_crv_circle_center(face_curves[1]) + + vd.addCurve(face_curves[0], (255,0,255)) + vd.addCurve(face_curves[1], (255,0,255)) + + f_0X = round(face_center_A.X, 3) + f_0Y = round(face_center_A.Y, 3) + f_0Z = round(face_center_A.Z, 3) + + f_1X = round(face_center_B.X, 3) + f_1Y = round(face_center_B.Y, 3) + f_1Z = round(face_center_B.Z, 3) + + sX = round(start_pt.X, 3) + sY = round(start_pt.Y, 3) + sZ = round(start_pt.Z, 3) + + eX = round(end_pt.X, 3) + eY = round(end_pt.Y, 3) + eZ = round(end_pt.Z, 3) + + if (f_0X == sX and f_0Y == sY and f_0Z == sZ) or (f_0X == eX and f_0Y == eY and f_0Z == eZ): # = start + if (f_1X == sX and f_1Y == sY and f_1Z == sZ) or (f_1X == eX and f_1Y == eY and f_1Z == eZ): # = end + ellipse_pt = face_curves[0].PointAtStart + radius = axis_ln.DistanceTo(ellipse_pt, False) + radius = round(radius, 3) + log.info("radius: " + str(radius)) + break + + ACIM.add_hole(p_GUID, + start_pt, + end_pt, + is_start_pt_accessible, + is_end_pt_accessible, + radius, + neighbours=neighbor_acim_str[i]) + + + + + + + + + diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py new file mode 100644 index 00000000..40b25fee --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -0,0 +1,252 @@ +import rhinoscriptsyntax as rs +import Rhino as rc +import scriptcontext as sc +import Rhino.Geometry as rg +import datetime as dt +import math + +import log +import hole +import cut +import util + +# import visual_debug as vd + +def get_lowest_brep_vertex(brep): + """ Get the the vertex with the lowest y,x and z values """ + biggest_vertices = brep.Vertices + lowest_x = 0 + lowest_y = 0 + lowest_z = 0 + for vertex in biggest_vertices: + if vertex.Location.X < lowest_x: + lowest_x = vertex.Location.X + if vertex.Location.Y < lowest_y: + lowest_y = vertex.Location.Y + if vertex.Location.Z < lowest_z: + lowest_z = vertex.Location.Z + return rc.Geometry.Point3d(lowest_x, lowest_y, lowest_z) + +def pln_2_pln_world_transform(brep): + """ Transform a brep to the world plane """ + print("Computing Oriented Bounding Boxes...") + + # find the longest edge of the brep + edges = brep.Edges + longest_edge = None + longest_edge_length = 0 + for edge in edges: + if edge.GetLength() > longest_edge_length: + longest_edge_length = edge.GetLength() + longest_edge = edge + + # find biggest face + face_indices = longest_edge.AdjacentFaces() + faces = [brep.Faces[face_index] for face_index in face_indices] + biggest_face = None + biggest_face_area = 0 + for face in faces: + if rg.AreaMassProperties.Compute(face).Area > biggest_face_area: + biggest_face_area = rg.AreaMassProperties.Compute(face).Area + biggest_face = face + + # get the plane of the biggest face + if biggest_face.TryGetPlane()[0] is False: + print("Could not find plane for longest edge. Exiting...") + return + plane_src = biggest_face.TryGetPlane()[1] + plane_tgt = rc.Geometry.Plane.WorldXY + print("Found plane for longest edge: " + str(plane_src)) + + # plane to plane transformation + plane_to_world = rc.Geometry.Transform.PlaneToPlane(plane_src, plane_tgt) + brep.Transform(plane_to_world) + + # adjust to x,y,z positive + lowest_vertex = get_lowest_brep_vertex(brep) + lowest_vertex_transform = rc.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) + brep.Transform(lowest_vertex_transform) + + bbox = brep.GetBoundingBox(True) + bbox_corners = bbox.GetCorners() + y_val_sum = 0 + x_val_sum = 0 + for corner in bbox_corners: + y_val_sum += corner.Y + x_val_sum += corner.X + + if x_val_sum > y_val_sum: + print("Bounding box is alligned to x axis. No rotation needed.") + else: + print("Bounding box is not alligned to y axis. A 90 deg rotation is needed.") + rot_90_z = rc.Geometry.Transform.Rotation(math.radians(90), rg.Vector3d.ZAxis, rg.Point3d.Origin) + brep.Transform(rot_90_z) + lowest_vertex = get_lowest_brep_vertex(brep) + + lowest_vertex_transform = rc.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) + brep.Transform(lowest_vertex_transform) + + # vd.addBrep(brep, clr=(255, 0, 0, 30)) + +def distinguish_holes_cuts(breps): + """ + Analyse the result breps from the boolean difference operation + and distinguish between holes and cuts + """ + is_hole = False + is_cut = False + is_mix = False + holes_b = [] + cuts_b = [] + mix_b = [] + + # parse holes, cuts and mix + for b in breps: + 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 = 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: + holes_b.append(b) + elif is_cut: + cuts_b.append(b) + elif is_mix: + mix_b.append(b) + + is_hole = False + is_cut = False + is_mix = False + + # deal with mix + candidate_cuts = [] + candidate_holes = [] + for b in mix_b: + # -- 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 = 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 = rc.Geometry.Brep.CreateBooleanUnion(flat_faces_b, sc.doc.ModelAbsoluteTolerance) + non_flat_faces_b = rc.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: + cuts_b.append(f_b) + for f_b in non_flat_faces_b: + if f_b is not None: + if f_b.IsSolid: + holes_b.append(f_b) + + return holes_b, cuts_b + +def main(): + + # vd.set_on() + # print(vd.__IS_VDEBUG__) + + print(".acim exporter started") + rh_doc_path = rs.DocumentPath() + timestamp = dt.datetime.now().strftime("%Y%m%d_%H%M%S") + acim_path = rh_doc_path + timestamp + print("Creating ACIM file at: " + acim_path) + ACIM = acim.ACIM(acim_path) + + pieces = rs.GetObjects("Select pieces to be exported", rs.filter.polysurface, preselect=True) + if not pieces: + print("No pieces selected. Exiting...") + return + print("Selected " + str(len(pieces)) + " pieces.") + + for p_GUID in pieces: + print("Processing piece: " + str(p_GUID)) + ACIM.add_timber(str(p_GUID)) + ACIM.add_timber_state(str(p_GUID), 0) + brep = rs.coercebrep(p_GUID) + + # transform to world plane + pln_2_pln_world_transform(brep) + + # compute the bounding box + bbox = brep.GetBoundingBox(True) + bbox_b = bbox.ToBrep() + ACIM.add_bbox(str(p_GUID), bbox.GetCorners()) + + # boolean difference between the bounding box and the brep transformed + brep_result = rc.Geometry.Brep.CreateBooleanDifference(bbox_b, brep, sc.doc.ModelAbsoluteTolerance) + if brep_result is None or len(brep_result) == 0: + log.error("No breps found after boolean difference. Exiting...") + return + + # get holes and cuts breps + holes_b, cuts_b = distinguish_holes_cuts(brep_result) + print("Found:\n" \ + + "\t --holes: " + str(len(holes_b)) + "\n" \ + + "\t --cuts: " + str(len(cuts_b)) + "\n") + + # analyse and loading holes and cuts into .acim + if holes_b.__len__() != 0: + for hole_b in holes_b: + # vd.addBrep(hole_b, clr=(255, 255, 0, 30)) + print("Processing hole: " + str(hole_b)) + hole.parse_data_from_brep(ACIM, str(p_GUID), hole_b, bbox_b) + + if cuts_b.__len__() != 0: + cut_counter = 1 + for cut_b in cuts_b: + # vd.addBrep(cut_b, clr=(255, 0, 255, 30)) + print("Processing cut: " + str(cut_b)) + cut.parse_data_from_brep(ACIM, str(p_GUID), cut_b, bbox_b) + + # vd.addSingleDot(cut_b.GetBoundingBox(True).Center, str(cut_counter), (0,0,255)) + cut_counter += 1 + + sc.doc.Views.Redraw() + ACIM.dump_data() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_transformations.py b/src/gh/diffCheck/diffCheck/df_transformations.py new file mode 100644 index 00000000..7e3b434c --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_transformations.py @@ -0,0 +1,123 @@ +import Rhino +import Rhino.Geometry as rg +import scriptcontext as sc + +import numpy as np + +def get_inverse_transformation(x_form : Rhino.Geometry.Transform) -> Rhino.Geometry.Transform: + """ + Get the inverse of a transformation + + :param x_form: the transformation to get the inverse from + :return: the inverse transformation + """ + transformation_matrix = np.array([ + [x_form.M00, x_form.M01, x_form.M02, x_form.M03], + [x_form.M10, x_form.M11, x_form.M12, x_form.M13], + [x_form.M20, x_form.M21, x_form.M22, x_form.M23], + [x_form.M30, x_form.M31, x_form.M32, x_form.M33] + ]) + inverse_transformation_matrix = np.linalg.inv(transformation_matrix) + + x_form_back = Rhino.Geometry.Transform() + for i in range(4): + for j in range(4): + x_form_back[i, j] = inverse_transformation_matrix[i, j] + + return x_form_back + +def pln_2_pln_world_transform(brep : Rhino.Geometry.Brep) -> Rhino.Geometry.Transform: + """ + Transform a brep (beam) to the world plane + + :param brep: the brep to transform + :return: the transformation + """ + def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: + """ + Get the the vertex with the lowest y,x and z values + + :param brep: the brep to get the lowest vertex from + :return: the lowest vertex + """ + biggest_vertices = brep.Vertices + lowest_x = 0 + lowest_y = 0 + lowest_z = 0 + for vertex in biggest_vertices: + if vertex.Location.X < lowest_x: + lowest_x = vertex.Location.X + if vertex.Location.Y < lowest_y: + lowest_y = vertex.Location.Y + if vertex.Location.Z < lowest_z: + lowest_z = vertex.Location.Z + return Rhino.Geometry.Point3d(lowest_x, lowest_y, lowest_z) + + # find the longest edge of the brep + edges = brep.Edges + longest_edge = None + longest_edge_length = 0 + for edge in edges: + if edge.GetLength() > longest_edge_length: + longest_edge_length = edge.GetLength() + longest_edge = edge + + # find biggest face + face_indices = longest_edge.AdjacentFaces() + faces = [brep.Faces[face_index] for face_index in face_indices] + biggest_face = None + biggest_face_area = 0 + for face in faces: + if rg.AreaMassProperties.Compute(face).Area > biggest_face_area: + biggest_face_area = rg.AreaMassProperties.Compute(face).Area + biggest_face = face + + # 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 + plane_src = biggest_face.TryGetPlane()[1] + plane_tgt = Rhino.Geometry.Plane.WorldXY + print("Found plane for longest edge: " + str(plane_src)) + + # plane to plane transformation + x_form_pln2pln = Rhino.Geometry.Transform.PlaneToPlane(plane_src, plane_tgt) + brep.Transform(x_form_pln2pln) + + # adjust to x,y,z positive + lowest_vertex = _get_lowest_brep_vertex(brep) + x_form_transl_A = Rhino.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) + brep.Transform(x_form_transl_A) + + # aabb + bbox = brep.GetBoundingBox(True) + bbox_corners = bbox.GetCorners() + y_val_sum = 0 + x_val_sum = 0 + for corner in bbox_corners: + y_val_sum += corner.Y + x_val_sum += corner.X + + # check if a 90 deg rotation is needed (for the joint detector) + x_form_transl_B = None + x_form_rot90z = None + if x_val_sum > y_val_sum: + print("Bounding box is alligned to x axis. No rotation needed.") + else: + print("Bounding box is not alligned to y axis. A 90 deg rotation is needed.") + x_form_rot90z = Rhino.Geometry.Transform.Rotation(math.radians(90), rg.Vector3d.ZAxis, rg.Point3d.Origin) + brep.Transform(x_form_rot90z) + lowest_vertex = _get_lowest_brep_vertex(brep) + + x_form_transl_B = Rhino.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) + brep.Transform(x_form_transl_B) + + # resume the transformations in one + x_form = Rhino.Geometry.Transform.Identity + if x_form_transl_B: + Rhino.Geometry.Transform.TryGetInverse(x_form_transl_B) + Rhino.Geometry.Transform.TryGetInverse(x_form_rot90z) + x_form = x_form_transl_B * x_form_rot90z + x_form = x_form * x_form_transl_A * x_form_pln2pln + + return x_form \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index 61cc5684..f9d5d644 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -1,33 +1,178 @@ #! python3 import Rhino import Rhino.Geometry as rg +import scriptcontext as sc import os import typing -from df_geometries import DFBeam, DFAssembly # diffCheck.df_geometries +from df_geometries import DFBeam, DFAssembly # diffCheck. +import df_transformations # diffCheck. -if __name__ == "__main__": - """ - Main function to test the package - :param i_breps: list of breps - :param i_export_dir: directory to export the xml - :param i_dump: whether to dump the xml + + + # vd.addBrep(brep, clr=(255, 0, 0, 30)) + + +def distinguish_holes_cuts(breps) -> typing.Tuple[typing.List[Rhino.Geometry.Brep], typing.List[Rhino.Geometry.Brep]]: + """ + Analyse the result breps from the boolean difference operation + and distinguish between holes and cuts + + :param breps: list of breps + :return: holes and cuts breps """ - # beams - beams : typing.List[DFBeam] = [] - for brep in i_breps: - beam = DFBeam.from_brep(brep) - beams.append(beam) - - # assembly - assembly1 = DFAssembly(beams, "Assembly1") - print(assembly1.beams) - print(assembly1) - - # dump the xml - xml : str = assembly1.to_xml() - if i_dump: - assembly1.dump(xml, i_export_dir) - o_xml = xml \ No newline at end of file + is_hole = False + is_cut = False + is_mix = False + holes_b = [] + cuts_b = [] + mix_b = [] + + # parse holes, cuts and mix + for b in breps: + 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 = 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: + holes_b.append(b) + elif is_cut: + cuts_b.append(b) + elif is_mix: + mix_b.append(b) + + is_hole = False + is_cut = False + is_mix = False + + # deal with mix + candidate_cuts = [] + candidate_holes = [] + for b in mix_b: + # -- 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 = 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: + cuts_b.append(f_b) + for f_b in non_flat_faces_b: + if f_b is not None: + if f_b.IsSolid: + holes_b.append(f_b) + + return holes_b, cuts_b + + +if __name__ == "__main__": + + print("Running diffCheck...") + x_form = df_transformations.pln_2_pln_world_transform(i_brep) + + # transformation to matrix + i_brep_copy.Transform(x_form) + + # reverse the transformation + x_form_back = df_transformations.get_inverse_transformation(x_form) + + # i_brep.Transform(x_form_back) + + + o_brep = i_brep + + + # compute the bounding box + bbox = i_brep.GetBoundingBox(True) + bbox_b = bbox.ToBrep() + + print("Bounding box computed...") + # boolean difference between the bounding box and the brep transformed + brep_result = Rhino.Geometry.Brep.CreateBooleanDifference(bbox_b, i_brep, sc.doc.ModelAbsoluteTolerance) + if brep_result is None or len(brep_result) == 0: + print("No breps found after boolean difference. Exiting...") + # return + + # distinguish holes and cuts + holes_b, cuts_b = distinguish_holes_cuts(brep_result) + + for b in holes_b: + b.Transform(x_form_back) + for b in cuts_b: + b.Transform(x_form_back) + + o_brep = cuts_b + ################################################################## + + # """ + # Main function to test the package + # :param i_breps: list of breps + # :param i_export_dir: directory to export the xml + # :param i_dump: whether to dump the xml + # """ + # # beams + # beams : typing.List[DFBeam] = [] + # for brep in i_breps: + # beam = DFBeam.from_brep(brep) + # beams.append(beam) + + # # assembly + # assembly1 = DFAssembly(beams, "Assembly1") + # print(assembly1.beams) + # print(assembly1) + + # # dump the xml + # xml : str = assembly1.to_xml() + # if i_dump: + # assembly1.dump(xml, i_export_dir) + # o_xml = xml \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/joint_detector.py b/src/gh/diffCheck/diffCheck/joint_detector.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index ccd49548..0de0df29 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 82 - -295 + -192 + -8 - 1.5 + 1.7647058 @@ -69,7 +69,7 @@ - F:\diffCheck\src\gh\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck\diffCheck_app.py @@ -99,9 +99,9 @@ - 9 + 12 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -132,10 +132,10 @@ - 187 - 113 - 138 - 84 + 213 + 133 + 115 + 44 267 @@ -144,17 +144,15 @@ - - 4 + + 2 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 @@ -177,102 +175,31 @@ - 189 - 115 - 63 - 20 - - - 222 - 125 - - - - - - - - true - Converts to collection of boolean values - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC - - 509e66b1-9c06-47bc-9e26-3bcd45a184ca - i_dump - i_dump - true - 0 - true - 5de6f2a8-d2d0-49e6-92b4-ae1ed47ccbfd - 1 - - d60527f5-b5af-4ef6-8970-5f96fe412559 - - - - - - 189 + 215 135 - 63 + 37 20 - 222 + 235 145 - + - true - Converts to collection of text fragments - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== - - 8f3ff1eb-ddb8-455d-81fb-cb1cf0c575a5 - i_export_dir - i_export_dir - true - 0 - true - 56e42677-eccb-444a-9bab-e6a34770f1dd - 1 - - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 - - - - - - 189 - 155 - 63 - 20 - - - 222 - 165 - - - - - - - - 1 true Converts to collection of Breps (Boundary REPresentations) iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= ae8c9c0d-8d6a-4a8c-812a-110846a2031c - i_breps - i_breps + i_brep + i_brep true - 1 + 0 true 0f309845-29e6-43ae-b255-cdb5c2d13da9 1 @@ -283,14 +210,14 @@ - 189 - 175 - 63 + 215 + 155 + 37 20 - 222 - 185 + 235 + 165 @@ -318,13 +245,13 @@ 282 - 115 - 41 - 40 + 135 + 44 + 20 - 302.5 - 135 + 304 + 145 @@ -333,19 +260,19 @@ false - Generic example output of the component + No conversion - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - f5d7e77d-04d1-4395-b52b-651450a4b329 - o_xml - o_xml + a849584f-8d8a-4547-a1a4-36be0bf3ac37 + o_brep + o_brep false 0 true 0 - Generic example output of the component - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + 6a184b65-baa3-42d1-a548-3915b401de53 @@ -353,12 +280,12 @@ 282 155 - 41 - 40 + 44 + 20 - 302.5 - 175 + 304 + 165 @@ -368,7 +295,7 @@ - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)


                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_dump: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep]):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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)
 + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self, btn: bool, i_brep: Rhino.Geometry.Brep):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -405,8 +332,8 @@ - 102 - 97 + 116 + 125 66 22 @@ -423,8 +350,9 @@ - + Contains a collection of Breps (Boundary REPresentations) + true 0f309845-29e6-43ae-b255-cdb5c2d13da9 Brep Brep @@ -435,14 +363,14 @@ - 118 - 181 + 131 + 153 50 24 - 143.71587 - 193.00317 + 156.24402 + 165.29077 @@ -453,32 +381,16 @@ - 3 + 1 {0} - + - 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 - - 00000000-0000-0000-0000-000000000000 - - - - - - 7F0JVBTH059d7lPwvvDAM4IKIngg7LCACAZFvBWNqBhEBcQTL7wSNWrURI0aY4wHSdREjUckRljwFpVIlGgABfGOMcaLxItveu1aO80M7P6V783y+vfeMNsz3bNV3V3V1VU1LKfgOK5EADoj2CqFP/3Co0fHxvnHjRsXF+vaqF9UwoTRcbE+Hdu0b9OuvVv79m3cPd3c3F0b+U8aO3FSQpRPbNSkiQmRY10bhU0aPnb0iO5RiX3ixkTF+nh6tmvX0T2qU4cRHTw9PT3czNCXVNM+u01QVNy4qIkJiW3UCVHxpsJ1i8mvvsY6MmFE9OjJUR4jx1nFxUfFxk5KGD7BdGTkxEhUydLSUokodGjBce2E86DRDrZWJsKHKujP19kcp3yapOQ+Fz4gPCtRctUxZ/4Zcfdbbbbs+sXFr7OPnG3l1fLljs7PhfsjcN123GyO393pVcGhm/AHkYuedogr/bQ6jjuH9rI575j2knOYp3C+H1I3sRZ62gf4vgOiEgGd4fNr3FeVuvTqehp9hWzbJqVj3mqnAXzp572+B+VJUR8cKElSzoay7JjpFe64xuOjVlpmaOKhDHWKk5+PkCUzGXO6zvwnrDdPjsyu/BPTE9t56IinGY61W3JIlszQhIpdo9sVd9LMlCUzMCI/Hnm45s+vB4lOM7gH5btXa0XJkhmxkaGJhzLUufT43j2jGRmaeFoB+LcatlCWzJSlzWhmoO5kn7UmsmQGRuGh7+rOGcNHi04zuAflSIvoj2XJjNjI0MRDGeoc9ip5IUtmHG+N3OdVNfo/I5OY0G+zafAQHfG0DH2Vd/2BLJkpS5vRzEDdAbGL5TnNYEReERwjOs3gHpT3dXvRWJbMSI/Ma+KhDHVarl+32WhGhiaeVgBXEl80lCUzZWkzmhmoq/5u3ReyZqZS7Gf0MTShHBJx8fq+8Kb8rodPRxqNBUATD/WhPOnZjBpGowBo4ul29lnRR2XJDOA7vLsUkxm4B+Xeob/PkyUzlVJmpmF7TExmxtjknEua0VdXLgrqI0+HRqWSGdPuxWduDnPS4Euz0bUNAwofn8oJ0y2aX+DyVwNdhiftqcUv8P1thNEwE+0+ou724J48vsdDGdod/z6zhyyZ2Yh7mzRnCgd9E1JQI4iHewW4DHW6VymONhpmSjKLC92LRryWldOvyko8UhaTvX6WJTNYPjS49zXoGi0j9EgVJo/9SJbMwBQCoUfXsjITh/u9DNSpYlpm9l+emilLZnQE4SmErsGaAyND+wSOP+ScjYaZq4dTh+y630c3EoW4DHXGc4PzjEY1nz/7d0pcSKRuJKAMMhOa/ORdo2Em2mt3YoBPJF8SgtcZXIZ2lj9OkWdIA/e6BsuJVpvRI0HL0ER/BydZMgOEAgNiMlPD8dScZyFhOu2mrNdooCyZwcKtwepXOzK0lQxqG9q1z97iZjTM0NqLttXuTKjaU5bMYNNFg4VcQy6kUM+noJtiq9vraXast3OQ0TBD22K0dpuhzJRnFADAzx2ytm09H9FgE72/ub3E5pgsmQFCSScgLfC0T2BYQMoKWTJT0uHczoDZkfz08AahwWOjtMyE3fbtP9ErqpQFAOUsB4/PZMkMEAoMKEUEfkm/IUs77OZ1ZdOf42JkyQyoXVgoyWtQj15E51o9O86YqfCRAbWLt8rkNahHb6MvOrd+YTTM0LYYvfO89tMjhSyZwRpKgy1k7aJ5cXFeoN09H532ysZlsJpn7L4bZjTMnB5Ub3AzdYjOFoMytLs36N4XRuNq2o29/jASdP7ZpIHLSoyGmWjXMQ2O8q8FHspgRbf88/tTsmQGy4Pm+1e9r51mtIzQI3V6keNwWTKDmdAJObrmErIj/tGCbjrtlUnJzKrwe/1kyYyYqwlMGxgJ2lZbMu33JkbDzGX3ZvxfX742Z67gMuxvvnEZKs+0RnMRV1ON9+b8cmPpKN1IQBlGKm1qXoTRMLN1f8ut4bcjddprCy5Du8iGE9fLkhnc6xosF1ptRo8ELUN9/u6RKEtmgFBgAF3Lo2TGu/H+vqnXQ3Xa7cSdAnmaM1jYNdhk0Y4MvRm7hNU2tPsgem4No2GG1l60rXY/KzlHlsxgU0WDhVzLDJ2RUfwyOSw32Us3Ujv2JxUbDTO0LUZrN/P1i+T5LsCMWifHhTYL5juuTv+o2qZXYUA6ukzvb47eC1skS2ZAuIEB8hrUK+Wu3V6QKuvcmc4ZH3tltxwmmtZIWwTJpuPtZMlMdUwomTxHCzzU1znOU7zlGWwC8x6MS3LbDPVow9PnD6sfZMnMKUw4rPokg1CPtgiUYRt3yZIZMCJBHZPXoB69je4TuKfQaJihbTF651kz3PI/LwPN/8T8GHp506khJrApweEZAzhcBRyavEUOAWScI2WG1UFXq758+pfTtmSGDeEt3VIW1O0Zyj/r0bpb10OBfJcHvYZ5n2yhmZ+++crZ+cGakORPHcSGTzbMkS4cKSZat1IE2U0I4oetj2/36+n2mouXxnXpcStAU5g6Z6asmQOHmtabGDOhs8O1vvzf+2/5p9YczOcunrLqzOMwflTj7IWNLvfmuzjn+B74tg9v6vhTVIgyiK/ZdU5roxk5qWkpxXTdXVW+kSVzYvnFUtPSuV3955mzQ3TXQ0/29LIP7q5ZVm/MblkyJzZyUkz0s7v/9BOvd3Uyt7GwzqdLd3TV/H2x1gWjGTkpxSHFnP3vPwfKkjmxtyukRi70Hrfqr5j+OlnkW9q5537Unb/So+1BWTInNi2lmLiZG1P918ABOoVSvKDxne+qhfHqooSWsmROLMdfavrlTQ095xjbg794Jm3w5St1NXsGmQb4/cBr+nmd7C5L5sRy/qVGTmqJeLi4scJomJOaflLr3LqsNDtZMieWqzl2U1T6+lWhfJtb1Y6luLTjR8dZBW6Z2FhzI2nZwZ6b3+UXufSMPVanA3/ecvmO1ttcNDmJUfmyZE4sPBj6ZGlm56Vh/LkVDxt+fTCY33b88y/dZjflV1gk9og078W3vH8hc2NAEN8q0tnip31t+MMfWBySJXNimelSzEmN3KYj0XdlyZxYkCq835TMI9NDeU7Z/Y/vNzxPq6K48cVmlb+ktty86dYNo5G5kw/G5nye0EtwTX3TeflWT77ruuuHkzc4a+YXzuk96d8w/mVQ0dX1n3bm93qMdXE776q5lLU9TpbMiaUYS42cFHM/ffjERpbMiWXpSk0/KS36tSJjryyZE0t0ldKKUtN1hPOBQlkyJ5YrKjVCUruF9JtLBsqSObF0S6kRyp6z/KBTeh/+ymef9Hv+a0++3u/Nl0QO7syv3BLQXJbMiaVfSq1nUopmqNM4tTyZE0n6k9KKUot77Q/b/itL5sTy5pyqnY1Y9nM4bxK/4oBZ1V78qT3H1n1+i+d/VxRdivYP53/nN15dGBrOX6l7ak7C/i78sy3RG43GtnR2uGn2dGRvvurDa9He1/vy22Iu2tyaGCDp2mt51cxRlsyJZW9JMSc1cg9+OtxflsyJ2ZZL47d2LA7qwx+rP6DvnGa9+KilIy6u5z15KW152HRggSyZE8shqrt85c3vr/blW75cunvXnN58yCnzFe8F+fM5s74duXB0X57LWp/rcagPf79Jsw4vUnh+21eOwbJkTiwNR2rkpJhzfeJjL0vmxDJZpKaflBb9cvzAeFkyJ5YMIqUVpabr/DYWB2TJ3EWRfAqpEZIyqPctLhksS+bEUhKkRkjKK5ZyYeljWTJ3WiRFQWo9k1I0gc0tkmTJnFhgXEorSi3udzcc+49C+et0khkKlAc5YILtCY7rKEpzXOvEsKAiguPtLT9ORRwXSnFc0f8dDOw10/8hWmloXLrWqU5nxKaGbDpKLFYm1lGGMm5oMDH3acEQWXeUWNxNrKMMZdzQ8Jb37qkdZN1RZf33J7KjDGXcUFEt6dg+SNYdVZaO0r0SK3yWYlyqA/VNUuiBZ2Z6cVzl6CipmSA1o8rLCRhKiWovl3Rzo+0oUvRW3fUOedQkhJ9ZMOXKvBYDeP7uYY8dc0P5E8erBB+81J3/rvj6rMl/9uX/uT1jzOoqvfhfau5eu/hFKG87M7i+/X43jdc7G32mbgnRmD6YvyZ8T0++R6MVG/w3dNIs9ItZV2zRVTP0k+1hlUKZ9z88xyFsrWCrB83P/W1oU03bzRbFtccGa+7v+mOZx8Rw/vwxq/ivanlo5h4813tNVoAmIeLjc5YDe/K5++uMcT05kA9IiJhmc7AHn13P/db7C8J4m7MLrBsu688/dT1pf2x7L75Fj8+CZd1R+oqe1IyS6pCzEjMKOtwVd7gb7vDsO25Ko+0ockYF2vhcTT7O874Xc3+yfdKfXzje4fjV0DB+yg2HwnEz1XzsX8GDSg725YdGba/dZH04X7jxXoupHw7iU2ebuOc5d+fvx+5q1aL/i7RpHw/4enDkYL7Bzitx6d935Xc0Nunp/bETn+tW2KBSiF5PZ8X50B4RfN6p41/9djKMj8htUpKa15C/WWVMb/d3hvC1j4yZu7JhKO9xrL25u5s7X9d+eOfw/gF8ytXGAZPbDOb/if+ut016OP/ubc9Odey68nf+XVYU/WgA/8vIblu7V+nLz75+/l9Zd5S+oic1o6Q6pIiaUY3iXs0oqQ7f1/TwwErRUcw8kGlHTV+zPhy5FG6b4llSG9+QsnxhFqGzNcEEmpFS1q8JUceUmkFSDJjg+ubCAVMcvleqk0zwM9HZhmhT1t7QBN83Ew4Log0qS+0bTfB9RJsV0QaVpXYGJvj5llS/oWtSg2uC6yNeGhNtLMsIn6M2trjPqhJtrMoI3EIb5E6qSbRBdErFPVEbO9ymFtEG0SrlZoU21YSjEdEGfbdU8Fj742DC4UjRZldG8ge0saL6wL6MyDxqg9xqNTB9gCplxIShjSPVBw5luKBRm9qY/wZEG8cynJ/Qpq5wOBNtEG9SvkPUpg5u04RoU60M3z+0QTKE38XRAs0lKQcsalMP8UvRVqOMAAq0qUH1Qc0yvNuoTX0sByRttcrwq0IbJ6oPShbHzEBK7x1r4oUjMZD/vwwpI9DaDmXURfXw8lzKuIJnoENBKRy6rtjyDG+ymOCBhDqkghSrayLxHegzqTTtyqDHlFDetOcSFDt6jimezJxEXaQ4zcr4DjP8HDNKidN1kbI1l/gOaK+NyeKJJkWPBTEOtIFsitsrsdIllQldF923LINWC/wcK6xUpPiyIhYVOm3dDI8Reo41pRDputbEQkP7BaHflFj5kgqPrmtDjAN9z4KYP/RCQNdF34MOTiQH0xLzrMSKDikhTqKuHTFP6TQQa0yrNkyGlQwnURfRiw5OJJvXmqAHFAgnUbeKyHhCcoMtMV4NKMVF13Ug9ArNsz3+DiVeOEhjgK7rSMgfnQ5qSzzHmVKKdN2qxHynMy8RT5b4Oc2Eg9SfdN1qxPyikxzRWNnj57QQjubEc+i61Qk9R+cTAi3oaCkc7xDPoevWIPQBnbpnj++h57QSDhfiOXTdmoT80VlyaO7Y4ue4Ckdr4jl03VqE3NAJaWisrCFaJBxtyedQdZHcgPFO536BkYKe4yYc7sRz6Lp1CPmjZaYqse6gn2/1IJ5D10Xyhw5OJKOpKkFPe+HwJJ5D161HyTEpM9WJ8fISjg5UPbIukmN0cCJ5OjXxGKDndBQO/CuyonWdCH1Ap8RUJ57TWTi8iefQdRsQxg+dfYJ4csDP8RGOLsRz6LoNCb1CJ3qgsaqJn4P29b7Ec+i6jQijnM6pcCD0KjIa/Ijn0HUbE/qJTl+oSayDauHwJ55D13UmDEo6UwDNner4OQHCEUg8h67bhNBzdFAejVVV/JyuwhFEPIeu2/N6/UlaoxEpPPiJYRr0P7wFQxAMo7JAt9UXtMFJGpuk0QpGUVmQ+pnY8qAs4/d00SSE3TwYZGKg2xpKA23oAi/kdaCBNojfVj+AkUwbmaaU9wPmA71R4ETaGkoDbWADL+gaGNhAg5kEDXRbQ2kA45zmxZwwzMn5UBH9QBr2JC/wvaR8wPx82/0AmwJ6s4Dogs0FOR9K+2NLtzWUBnJDQfKC6IKNCdAAY/O2+wE2I/TvoCK67Ih5CPNBjAa6raE0kBsZkheQF1NqPlREP8AmiN4cWVN6EeaDmJ6i2xpKA7mBovUkAhknMCtHV/6v/QCbL7HNJnhKyflQEf1Ab9xIubAg9BLMh4roB3LTp4/9UJYNoe+6me3kseHQP9dL4AwbRn3WLJCTN9XVNA2w2dRHT5pL0GConqRpgI2qPrIJUYM3nZM0DeQml/61SHD6AQ2mEg47uq2hNMAGWWztJm1I+GxWAfMBNte0UwutF+AEAxrApqBBtzWUBtiYi+kocHxx5ThP33Q+wKaedvKgNQScZkCDlP1CtzWUBnAI6EuDeQXQAM4E2smA+hycfiQNYqDbGkoDOCL0pcGiAmgAJwb9K3/2eBwQHWSQQQx0W0NpAAcI7QhFNIDjFPqBE3GKcyJtDaWBdJ6QTh60noPTFWgg98BigLaG0kA6XvShwbwCaACnDS1fyKYAp3F5/fCmsgkOH31psKgAGsBZRP9eHLJrYDxIuRDrB7qtoTSAo4l2pCMabKl+kJILuq2hNCBHfFMRJzyyrcBpT9Igtm7SbQ2lAfnHmulJg5Q/6E1pQIGE5iJBBGQ/QdCB7Adyfwyg2xpKAwpotNCTBqWEXLwpDSgYgg76l8fAeWqph1+ObmsoDSgY845IIAbRAIEb0qYVm5N0W0NpQMGcViK/8wW2rr0e/ge6raE0oGCSi0ggCb4fglJAg9icpNsaSgMKRrmKBKGQrQ1BK6CB3HeRoNsaSgMKhrU2gAbLCqABBdPaiATRkL0PQTeSBjHZpNsaSgMK5rXVkwZzqX54QxpQMNBNJAiI9hwQNCzPrqbbGkoDCka6G0CDdQXQgIKZ7UTsc7TvgaBnef3wprY9CqZ6GECDTQXQgIKx7UV+DakuHoeqeuwv6LaG0oCCwZ4igWBEAwSOoR84Ql+QoNsaSgMKJqODts/R/g+CzhW9v+hABbTLo8G6AmhAwfCOIkFwtAeFoHl5/UC3NZQGFIzvZAANNhVAAwrmdxb5XR0n/P3V9dhf0G0NpQElE3iLJBIgGqpT/SAlF3RbQ2lAiQhdRJIQ0F4ckhZIGsRsGLqtoTSghAgfPWmARLm3TQNKpPAVSaJA/gBIuiD7Qcw3SLc1lAaU0KHSkwalhFy8KQ1oAvEiv9DSCH+fgx77C7qtoTSgZBQ/kR9WQTRA4gppy4nNSbqtoTSgZBa1yO+hNMa2Y0099hd0W0NpQMk0/iKJNIgGSLzhCBrE5iTd1lAaUDJOgMivjyDfDCTtkGMhJpt0W0NpQMlAgSI/GiJFg5iepNsaSgNKJuoqkkSE/EOQdETSICabdFtDaUDJTEF60mAu0Q9vSsNHH9e1QElTVkriP5Zw+MvcsLHZjkrKUWCnBdoAoEUeGX48YXhDUBKcBZDEQCZ02GIDDm36kSJAg9+AcNRD4EKNDZzOVLAXJga84lIF34d7psTmBIxzoAuCpE2x46MGoQCAXlPsJKuDN+QNCScxBD3rYQdSY7xZBeepJb7vhDfSTfBGUkHwZYoXaj/sCHPB9yFIYIoXUXcssB0II9IG3/fAC0wnPJnBuLLF9z2xoHnjiaYg+swUL5D+lIGE7k0pXv0+mhSd8KRwhEkhtrOCQaWz3EiLk9SmkMlDR+zJaDaZeQWZJ2aUBED0HzKZoD5MNMguguvgSaNfA7AiOp7UuBCpgYgJPMeG6GiowxEebFtKW9gRHVtedl9lQqPPFlWB9w3h/Tz4rxrwPh28gwfvB6JJZ4+0jgAFeo82wLT0e7TXzv/WI+j2r45p11+9R9s6pV4Eeo/WFtf1tKXWrSkj7NoGrkrVvTe7vHeDQf1r3NWVaZ8l7M3hOpTb3Wmt/nxUcvrU5u9mzGu0Uz30wzvq2O8XCBpqtvAs3ZFGHP+5ViJAgVhcjb9Iu0EUex0JobV//T+uetUt9bav2KtNCAsCbobU7p+jenXer22nlbt1axFuqzjtd4PRSerKV+JpPsRml4vHmSVw14aztrYQ+lHB2djYmCoUVtaWluYWSiWntLAwMVcqzU3MzKwtLC2XC3WXdanFax//JX781N8Vy7m4klHB36iHCN10fmqMeq7QZQ/2XVSPE7rMQ+jK/GDf9ClCV45Z461eJ3RrgrpFhtnfG9QZoVvVfap2VN/cMVZ9dsgKP+etNumz6kap25894Deu15D0nNHz1R3zQ9VzFU39bDwWqs2adVaf+W6S3/Rrq9Stly9U5wVYqIPqfaLuOvYT9Sd7rvv90uJzdd47O9V+XzdR+171bfhk9IvmiOb93dsnammGpPOpv08/22/XFXX/Kb+OyQmdnGWhqMddc1EpVOPG5w8T7h/Z8vQq9862R0gt64DKB7cN03Y3nJMuttMmcicU1FcdilngA+fbjr9pr8P5l5jFvug6nKEdjEBG8sKU5MivA7fdW/fnrEdFNZH13zHSYZuW6lE6qkcM09gr55m+X3vK6E63/tx7wCPUK0PR3L7o8LUOeT69howeaXsza/HUfx6f38d1TGqzMs0t3PvbWXsOHD78TY2hVQLynWry/1bZOGPN03r5UyISr1zK+PczofRyadizYTO4u/+oV1W94addDrYQpImR17xhQuOy31Gn8fbrIbqqKOs8FE4fzDza8z/v5iOF4m2iv0IxwXU9YTnaaz47+kBCgarJnkj7yF7XVCeD8qyf7j+pqtdn4YQfTmSrpJJqQIHAe+SkQlkvzPwJ3QZlrNsbqc4VJGK8IAWVVKEoOKUJUu45kwsec1IaYJh5H3WecD1B6JO1Qp8ghTtupGcGang3fVYgF/88NvXfDJ+0+fUbp+nzGRmX9xYlHOMsFzurfvkx1PfwKhPtGZVXBq7WltFZN09EpjYaSpeZ3p+WWivoNYIeeijr/L3GJ0cW80xWlJIjbfKhnnJkSS7MlrAgP05Voflb8vAvle1StfPVH6+ppndqeuKj1bdUUomCUgvze8Kc0clRmwztwhz/xezKujCbcRYWVoJpq+DMzMyEhdncwsrSxgotzFZWShNrG7S4PYnvNV1sQZYSr5n9D2oX6kv9ItRrhS5EC3Wc0IXL4yeoH77M0Vh/YpbR4vIY9cTH19KcXtTJuLJysXqO63d+HR9XT9+euUB9Y/15v3lfjUq/Z5msLvxylto6N9vvJ9UmtbXrIvV1021+U2vsVH9gt179vHNdtf+729Vf3t6qvp1lpu5+uOvGxOz2CxDNDtE/HSu9IA+L+2r7mEfrJv2aenPebDvOun4nRatJ53aiBXlW0KhlwgJc7OOY1kyFzv32Bqi4jUkqVEZnVM7MGuIL57wVHqorq89py+iMyr9cdtfWQ2dUrn05RFtGZ1Qmh1JsQZ4bU3+vluoYHdW5s649XPJj5ub6tTcO817ZsHbTjocPdM8s3JPffrt/8Nr4xNoNm783sPr+NUc9ap7dOfdBra4xLS7E1ZxyIOFe0dkZOwMOdFmSxrVqeD+7zc9HXGu0qVJ0+NHiYx2GTs353PyzBX9HPuAiDgVfOB/ZK8IIlckO14iO/x+LcooqfP6mwpv7TqikMjylFuUowWT9W5j9FwVJAGVSia18WJT/3nI9lpPSAlJmPGqYf3/x+2hR9hUWXJWw4Kr0+YwW5dgTibvwonzG59WifMYHlVU7A7WLMjrr5onEovzbnJxoXRIvVKZ/4Joeeigb8aI8MeKo89uVI3pRXn0qo/bUO7dUu69mZVUt/ENytwzyA9ehjIzby8JKgxblWcK8QnJ0QZg/lVWOTJRaf6ndjOs5HCkvpEyRRi+5EqOGO59+NI17/HheqtcFF9WtP9zT9PmM5Ciy7qMJ2lUwvXeQdhVcbfmedvVDZXTWlgmIydEvWbliLm7xIaangu63141PjvZGbhlSSo5UBsiRBSlHaGrYbxkywWPeBdXqBu9nz/EtUv3m2Wyhd/CvKvtRqifxXpdUUply0ImQxQflGGFzhIzbWMFKWyFYY1mCS6Sx4BKptHIk1FAolUgkpg/YcoIj3UDkRpG0XkkrFTXckJk0AMmSryAnaYKcqPT5jGTp9vGlJ7n1dXb45gWv863yqI4Kzgv3nPS9E6PQnsuTpWXjl3bTJURCxfJkZ4xNzrmkGX2NWZYGtUvu93bXpC+Lp5/5aEuhKm/DrdpO2TexbXdJ9enBWgvWlOSrpLIMcbY6n7KjvXpMW08eyjMFN+IjYZ40EHYwSJY8BZdipZalV2vSYrfHzTjShUrKFLmro+XIIvHsDM7aZopKmT/Yt6tT3VR9PiM5ivl0wFyuX1M7ZNP5ovOR53/53l7uqy2jMyqXJ0c/LDwZqkskhYpQhiGlhx7KcN8I5Sjf9cjtipGjy1iO/mnR90ZSxGVVYWg392XhhSrIUuVO/zdLVYk7UYPliMPlC4ILfraw+58v7PgLBE9AJ8Edf1ZwwVdSORLWI60cFcxYm8+R3g4y/ECGJUjvCGro1c17KJKjNEFGUgUZ8dXnM5KjjcMGPtXKUUnRA63cTFtprUJnVEbXUbk8Oaq7KaCOLhFZVxMPNQwxPfRQX2m8cjRvZ7jL27XtYI/U7P2OF57/dVlHVK4m+sCFvT+qsjITh/u9DCyllGBRLz5oMrBhkb9ukUfr0SRB96L1aIcwr5AczRPmT2WVI06pVCpMtP6G9HfXH+RImSHXIXKtIuXtjWy7D09Ojdfuk75PPuRzM6lYu/5kJK/Unnce3uiLrpcnS8px5oc4GGYYRnq46TWrhuOpOc9CwozZtpvvGJNSMbLk5Zx/7qhdnqqa6c0C5ZxCVZv6jz77Yso1FWT8+RR0U2x1e21IQyd+PG3ze/4xfrpOtRZ0MVqTOgk69y/BC91GCAXnC6HgSipLSrRPUioUSCRuhnW/ypHhb3L9Idco0jv/RrLU8vP4Iq0s1bK0VbWNLfD98+cmquLdi3xR+YljfW25PFlK8u6yUZfYCRVhuGFY6YTPJf2GLO2wmzdmWfpx2gdOFeO7O+cT8eCLkkxdYHrnZ9/Oqdf0nAr+5doVKlsSjOSQiBYrW0xppjOauwrpEwXCPLkmRG6QLAUJqRSVWJZgn/SB2b8LOTJ1hJQpMppFy1F7LyG5ffp8N1XK3saq02P3+erzGcmRz7lzC7VyhALS6JzXaJHv/efv+aIyOqNyeXKUGtrkG91/1YOKUIYhpYceyka8T2q9NiqzYuTo1H/kKEU11eb6i5SxR1VS2bbw9o4PliPYJ2UJqUfzhajnLSHSmShEQPOFNKS+QmpTJZUjYT3SytGQDoMvcmSUl0zBIlO8yKgwamhm4dkFyVGaICNpgoyk6vMZyVHajU2TsRyd8XklP/gc5aKVK3QuT46mve//QpdQDRXpoYYyDDnUVxivHB11C7z/duUIfOAB56cURsfn6vx2wZ4rb296WaByCdkR/2hBt1LZ+7CoH9lQ5PPHe658MC6j9chK0L1oPQoQ5hWSI7UwlyqrHHFKrV23p7tiMUfKDrkGkesUKWtvZNcNnPtslNb/jfx0QfNyfWs9tlChs19Ovi+6npqpfbVKx4iYHA1/em8NB0MMQ0oPNbxEAmXvxvv7pl4PNWa7jqu9OKli1qN3qh6cYNc3UxdL6uZn2WKHqkBHZPHL5LDcZK9ScvQPvq77ARtB96L16Jmgb1Fuw0Mhjl+JcxvQgoTE4er+po85Mm+BzG0g1yBybXojORp/+mBLbuw3g7RxJK1dh8+RLxQqdD0872G5cnTpyezzEl1FuJSoIS71T+WMT44mZ6/8jpSjiDCPqYgN8scdXuN44sFzqHGX7PHVyVbS4WwGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBuPG/wEAAP//AwA= - - 00000000-0000-0000-0000-000000000000 - - - - - - 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 + 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 - 00000000-0000-0000-0000-000000000000 + 491fb852-545c-48e6-b8e5-8848ae2eb894 @@ -509,20 +421,21 @@ - + - 366 - 44 + 355 + 0 343 - 73 + 166 0 0 0 - 366.4111 - 44.67153 + 355.2232 + 0.3242798 + true @@ -543,63 +456,6 @@ - - 06953bda-1d37-4d58-9b38-4b3c74e54c8f - File Path - - - - - Contains a collection of file paths - false - All files|*.* - 56e42677-eccb-444a-9bab-e6a34770f1dd - File Path - Path - false - 0 - - - - - - 118 - 154 - 50 - 24 - - - 143.98213 - 166.14787 - - - - - - 1 - - - - - 1 - {0} - - - - - false - F:\__TEMP\test\ - - - - - - - - - - - 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -612,7 +468,7 @@ Panel false - 0.42412034049630165 + 0.2985713966190815 bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e 1 Double click to edit panel content… @@ -621,17 +477,17 @@ - 426 - 126 - 604 + 445 + 295 + 118 183 0 0 0 - 426.19714 - 126.91681 + 445.13605 + 295.23444 @@ -652,39 +508,7 @@ - - - a8b97322-2d53-47cd-905e-b932c3ccd74e - Button - - - - - Button object with two values - False - True - 5de6f2a8-d2d0-49e6-92b4-ae1ed47ccbfd - Button - dump! - false - 0 - - - - - - 68 - 127 - 102 - 22 - - - - - - - - + 3ede854e-c753-40eb-84cb-b48008f14fd4 Text @@ -697,21 +521,21 @@ Text Txt false - f5d7e77d-04d1-4395-b52b-651450a4b329 + a7582614-58af-4e8e-ac5d-40e739284db1 1 - 348 - 186 + 375 + 373 50 24 - 373.8549 - 198.45097 + 400.89478 + 385.76862 @@ -719,146 +543,521 @@ - + c9b2d725-6f87-4b07-af90-bd9aefef68eb 066d0a87-236f-4eae-a0f4-9e42f5327962 - Script + Exporter to xml - - Scripting component + + true + true + 2 - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQsSURBVEhL3ZRdTFtlHMbxwmTGxCjRVKOyOTZ0Ywx6TnvaDhBhE8VlrjF6a/TCJToKo7AxvsYKGC8WY/RmoR+0Y4WOQVkZ5WN8tuLYF+LGiFSdK8zdaRzzI8Toex7/7zmnEC5rTEx8kn/aJu/7e58+53lPyn8q4WBblt7mcusPOmN6m/vn7DL3Xzk27496uz8m2jucUmXXc9rS5CWUOvMJfC+n1N2aXeZZFg75IBw6BQJDrAzAcKQbhsozfwi1wae0Lckpx+Zq5u75d6HM5xHtfoL7YTh8VoXTGGtCMBwNNSobkpXe5nFSJCv6slNhfUXnSsK1sToI49FzNL2Qavsh1Yf92pbkJNh8VUL56YhQ2UkToDkbMVb3RMTDPX9y51IdwRuG6ICh5A4Q7a2PG+xtzxrsgfVTd04ZsSb0k1Q/ABPBTY0jkBzjfnnJms6WrG55cd8Reb44VUOtl77U9Ya+rO2KUNEOsSpAc4by7oKhukeNpKaP3A4qYKmBPgludkxAapr0y3etFtzeB3xbAszvWcZc3mMaVhV3LNg8vwkVp9WGcLDyIDmcZ31egw+rzo+PEXxSOcDUHPXI3+/NR+xV4OZuYLYA8uVdtRpaFVXQrTpONITA/GFy1zzr1UhGVedNEViao7C0TMHUMlUix4rfx40iYOZF4JIFLCpOa2hVYmXH9VXXSkt6YeSuE3Fw5wQ3Hx8n+GQCvGJpnnLdmX4zlc0W3sbVPGDaDEQMYBey7gEpD2h4iqiq63cVTFnX8qwHYGwYXDQ1Xjjw9qf+Qm9fy1veMJ+P1KHf8xffKWI393yM2fxlXMkFpiRgQgBGdgLh7YB34wYNT/+guvsHxbEWh6E2vFL0YZ+OmnGC5hfcsUKZpf3Arb1Q8p6jvL9UI8HnRmBcDwxnAf0vgAW3fKehVYnVoTGpLqxmTRmbjo14sGTNWwXzWXydWvIa8HUxcL0QuJavRhIl+Gg2MLQD6Hse6EkHAmk+Da3KVD9QnniIZmqIyTFWQs4/W4XHqYLfKBUEvnoJSt4XCT4pqpEMZgKhDKB7M9CZBrldt0NDqzJXdD1kPDZ8VznAMQ6LY2I3W9rvVOCJSKiC7FqBzC7lyiwiyWxMkNnQTpmd3y6zYIbMAptk1v7MguzRvath10tqHHzE5Jj4wNwUbc9tmspkcTqAw3kkVEF2Ne9Xbem/I7bwihPzL6uR8LwpEhYR42w0K87CmXHWtzXOutPjrCPtE21LcmJzRU5+K5UKfmFay7t/G1hvxn3WtdnFOp6+z3y6f/Y2lWcK3sPlXVRB6vc49XuIV3Ab0LsVLLDRydcw75MuuTW1XNmQrDBZsIFFDQsYy1mrYHALryCYj5y7dS52MvWGfEL3sLYleWFGfJBu5QEWyhhg3ZtuUSQrFEmMOZ8IyycfLYU3Ze22/k+VkvI34q8RvMUeXlAAAAAASUVORK5CYII= + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= - 68e93733-269e-4deb-85f9-f55554589eb9 + 37244b65-1555-4735-bf3f-ab0481941fea true true true - Script - S + Exporter to xml + XMLout false false - true + false - 142 - 298 - 72 - 44 + 227 + 353 + 135 + 64 - 171 - 320 + 307 + 385 - 2 + 3 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa - 2 - 3ede854e-c753-40eb-84cb-b48008f14fd4 - 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa - + true - No conversion + Press button to export xml - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC - 2b845980-88f2-4f63-a0f7-1574827539c1 - x - x + 5c36c839-5c70-4ab8-a9fc-6cacff1c6955 + i_dump + i_dump true 0 true - 0 - - 6a184b65-baa3-42d1-a548-3915b401de53 + 83363e37-e611-4b77-bcde-c28b03d7ee96 + 1 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 - 144 - 300 - 12 + 229 + 355 + 63 20 - 151.5 - 310 + 262 + 365 - + true - No conversion + The directors where to export the xml file. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== - 5bcdf1ec-3568-4e90-b700-efefc0113dc5 - y - y + eec8c89f-334e-4696-b34e-61b913c98340 + i_export_dir + i_export_dir true 0 true - 0 - - 6a184b65-baa3-42d1-a548-3915b401de53 + 2bba20ed-c34b-45cd-b237-6fb28c1269ad + 1 + The directors where to export the xml file. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 - 144 - 320 - 12 + 229 + 375 + 63 20 - 151.5 - 330 + 262 + 385 - - - The execution information, as output and error streams - 9c06c502-948b-4734-bfa1-5b29e4707c6f - out - out - false - 0 - - - - - - 186 - 300 - 26 - 20 - - - 199 - 310 - + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + 1fbd84e2-0cb6-4f71-a6ce-ef8bd20d11f0 + i_breps + i_breps + true + 1 + true + 35b72f16-8924-45e9-9eff-a5eea8982d94 + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 229 + 395 + 63 + 20 + + + 262 + 405 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + a7582614-58af-4e8e-ac5d-40e739284db1 + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 322 + 355 + 38 + 60 + + + 341 + 385 + + + + + + + + + + IyEgcHl0aG9uMwojIHJlcXVpcmVtZW50czogZGlmZkNoZWNrCiIiIgpUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgoKOnBhcmFtIGlfYnJlcHM6IGxpc3Qgb2YgYnJlcHMKOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCjpwYXJhbSBpX2R1bXA6IHByZXNzIHRvIGR1bXAgdGhlIHhtbAoiIiIKaW1wb3J0IFN5c3RlbQppbXBvcnQgdHlwaW5nCgppbXBvcnQgUmhpbm8KaW1wb3J0IFJoaW5vLkdlb21ldHJ5IGFzIHJnCgpmcm9tIGdocHl0aG9ubGliLmNvbXBvbmVudGJhc2UgaW1wb3J0IGV4ZWN1dGluZ2NvbXBvbmVudCBhcyBjb21wb25lbnQKCmZyb20gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMgaW1wb3J0IERGQmVhbSwgREZBc3NlbWJseQoKCmNsYXNzIFhNTEV4cG9ydGVyKGNvbXBvbmVudCk6CiAgICBkZWYgUnVuU2NyaXB0KHNlbGYsCiAgICAgICAgICAgIGlfZHVtcDogYm9vbCwKICAgICAgICAgICAgaV9leHBvcnRfZGlyOiBzdHIsCiAgICAgICAgICAgIGlfYnJlcHM6IFN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLklMaXN0W1JoaW5vLkdlb21ldHJ5LkJyZXBdKToKICAgICAgICAiIiIKICAgICAgICBNYWluIGZ1bmN0aW9uIHRvIHRlc3QgdGhlIHBhY2thZ2UKICAgICAgICA6cGFyYW0gaV9kdW1wOiB3aGV0aGVyIHRvIGR1bXAgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zIDogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCAiQXNzZW1ibHkxIikKICAgICAgICBwcmludChhc3NlbWJseTEuYmVhbXMpCiAgICAgICAgcHJpbnQoYXNzZW1ibHkxKQoKICAgICAgICAjIGR1bXAgdGhlIHhtbAogICAgICAgIHhtbCA6IHN0ciA9IGFzc2VtYmx5MS50b194bWwoKQogICAgICAgIGlmIGlfZHVtcDoKICAgICAgICAgICAgYXNzZW1ibHkxLmR1bXAoeG1sLCBpX2V4cG9ydF9kaXIpCiAgICAgICAgb194bWwgPSB4bWwKCiAgICAgICAgcmV0dXJuIG9feG1s + S + + + + + *.*.python + 3.* + + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + 35b72f16-8924-45e9-9eff-a5eea8982d94 + Brep + Brep + false + 0 + + + + + + 156 + 398 + 50 + 24 + + + 181.23218 + 410.9286 + + + + + + 1 + + + + + 3 + {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 + + + + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 2bba20ed-c34b-45cd-b237-6fb28c1269ad + File Path + Path + false + 0 + + + + + + 156 + 372 + 50 + 24 + + + 181.49844 + 384.07333 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\__TEMP\test\ + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 83363e37-e611-4b77-bcde-c28b03d7ee96 + Button + dump! + false + 0 + + + + + + 104 + 344 + 102 + 22 + + + + + + + + + + 719467e6-7cf5-4848-99b0-c5dd57e5442c + 066d0a87-236f-4eae-a0f4-9e42f5327962 + Python 3 Script + + + + + + true + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== + + 692eaddb-c313-4649-8d06-bb4758e34447 + true + true + true + Python 3 Script + Py3 + + false + false + true + + + + + + 257 + 224 + 72 + 44 + + + 286 + 246 + + + + + + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 2 + 3ede854e-c753-40eb-84cb-b48008f14fd4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + No conversion + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 47ff6ae7-24ce-4f29-823d-93afd6bb4c78 + x + x + true + 0 + true + 0 + + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 259 + 226 + 12 + 20 + + + 266.5 + 236 + + + + + + + + true + No conversion + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + abe1ba7e-2994-43d0-9af7-cb2aaaa3f7c0 + y + y + true + 0 + true + 0 + + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 259 + 246 + 12 + 20 + + + 266.5 + 256 + + + + + + + + The execution information, as output and error streams + 155841e4-9095-4931-9b41-7d9131e024c3 + out + out + false + 0 + + + + + + 301 + 226 + 26 + 20 + + + 314 + 236 + @@ -870,7 +1069,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - 85f65616-883d-4997-93fa-54d4e44e80e2 + 127d1297-1eba-4798-aaa2-01a05a1b95d6 a a false @@ -884,14 +1083,14 @@ - 186 - 320 + 301 + 246 26 20 - 199 - 330 + 314 + 256 @@ -901,14 +1100,14 @@ - IiIiR3Jhc3Nob3BwZXIgU2NyaXB0IiIiDQphID0gIkhlbGxvIFB5dGhvbiAzIGluIEdyYXNzaG9wcGVyISINCnByaW50KGEpDQo= - S + aW1wb3J0IG9zDQoNCnBhdGggPSByIkY6XGRpZmZDaGVja1xzcmNcZ2hcZGlmZkNoZWNrXGRpZmZDaGVja19hcHAucHkiDQpwYXRoX2RpciA9IG9zLnBhdGguZGlybmFtZShwYXRoKQ0Kc3ViX2RpcnMgPSBbXQ0KZm9yIHJvb3QsIGRpcnMsIGZpbGVzIGluIG9zLndhbGsocGF0aF9kaXIpOg0KICAgIGZvciBkIGluIGRpcnM6DQogICAgICAgIHN1Yl9kaXJzLmFwcGVuZChvcy5wYXRoLmpvaW4ocm9vdCwgZCkpDQogICAgICAgIHByaW50KG9zLnBhdGguam9pbihyb290LCBkKSk= + Py3 - mcneel.pythonnet.python - 3.9.10 + *.*.python + 3.* @@ -917,6 +1116,59 @@ + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 63a2f4e1-c253-4fc3-9148-719323b802e1 + Panel + + false + 0 + 155841e4-9095-4931-9b41-7d9131e024c3 + 1 + Double click to edit panel content… + + + + + + 386 + 175 + 411 + 166 + + 0 + 0 + 0 + + 386.9042 + 175.51825 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + @@ -924,7 +1176,7 @@ - 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 + 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 From 0e11970c5ac499c7db78462de73010f3cc7823d9 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 8 Apr 2024 15:34:01 +0200 Subject: [PATCH 023/141] WIP-ADD: Registrations tested and produce csv for error and computation time. python plotter added --- plotter.py | 26 ++++ src/diffCheck/registration/registration.cc | 86 +++++++---- src/diffCheck/registration/registration.hh | 40 ++++- src/diffCheckApp.cc | 171 +++++++++++++++++---- 4 files changed, 268 insertions(+), 55 deletions(-) create mode 100644 plotter.py diff --git a/plotter.py b/plotter.py new file mode 100644 index 00000000..105f5328 --- /dev/null +++ b/plotter.py @@ -0,0 +1,26 @@ +import numpy as np +import matplotlib.pyplot as plt + +def main(): + # open csv file + time_data = np.genfromtxt('times.csv', delimiter=',', skip_header=1) + error_data = np.genfromtxt('errors.csv', delimiter=',', skip_header=1) + x = np.linspace(1, len(time_data), len(time_data)) + plt.plot(x, time_data) + plt.xlabel('Iteration') + plt.ylabel('Time [s]') + plt.title('Time vs Iteration: additive 00') + plt.legend(["FGR Feature Matching","FGR Correspondance","Ransac Correspondance","Ransac Feature Matching"]) + plt.show() + + + plt.plot(x, error_data) + plt.xlabel('Iteration') + plt.ylabel('Mean error [mm]') + plt.title('Error vs Iteration: additive 00') + plt.legend(["FGR Feature Matching","FGR Correspondance","Ransac Correspondance","Ransac Feature Matching"]) + plt.show() + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/src/diffCheck/registration/registration.cc b/src/diffCheck/registration/registration.cc index 64aab1a5..b2a65700 100644 --- a/src/diffCheck/registration/registration.cc +++ b/src/diffCheck/registration/registration.cc @@ -13,32 +13,18 @@ namespace diffCheck::registration distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud); return distances; } - /* - Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html - - Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). - point features historigrams generalize this concept by computing point features in a local neighborhood of a point, stored as higher-dimentional historigrams. - - For example, for a given point, you take all the neighboring points within a given radius, and create a complete graph on those vertices. - then for each edge of the graph you compute features that are then stored in a historigram of the original center point from which the sphere and the graph where built. - https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation proposes a simple example of such a historigram. - - PCL's documentation refers to this 2009 TUM PhD thesis (but largely outside the scope of our work): https://mediatum.ub.tum.de/doc/800632/941254.pdf - - Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). - */ open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->RandomDownSample(0.1); - targetO3D->RandomDownSample(0.1); + sourceO3D->VoxelDownSample(0.01); + targetO3D->VoxelDownSample(0.01); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + open3d::geometry::KDTreeSearchParamHybrid(3, 50)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + open3d::geometry::KDTreeSearchParamHybrid(0.25, 50)); std::shared_ptr option = std::make_shared(); option->maximum_correspondence_distance_ = 0.05; option->iteration_number_ = 100; @@ -52,18 +38,14 @@ namespace diffCheck::registration return result; } - /* - Very little information on this registration method compared to the previous one. - If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them. - https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html - */ + open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->RandomDownSample(0.1); - targetO3D->RandomDownSample(0.1); + sourceO3D->VoxelDownSample(0.01); + targetO3D->VoxelDownSample(0.01); std::shared_ptr option = std::make_shared(); option->maximum_correspondence_distance_ = 0.05; @@ -71,9 +53,9 @@ namespace diffCheck::registration option->maximum_tuple_count_ = 500; std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + open3d::geometry::KDTreeSearchParamHybrid(3, 50)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(0.25, 30)); + open3d::geometry::KDTreeSearchParamHybrid(3, 50)); open3d::pipelines::registration::CorrespondenceSet correspondanceset; @@ -85,4 +67,52 @@ namespace diffCheck::registration *option); return result; } -} \ No newline at end of file + + open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target) + { + std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); + std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); + + sourceO3D->VoxelDownSample(0.01); + targetO3D->VoxelDownSample(0.01); + + std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, + open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, + open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + + + open3d::pipelines::registration::CorrespondenceSet correspondanceset; + correspondanceset = open3d::pipelines::registration::CorrespondencesFromFeatures(*sourceFPFHFeatures, *targetFPFHFeatures); + + auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnCorrespondence(*sourceO3D, + *targetO3D, + correspondanceset, + 0.05, + open3d::pipelines::registration::TransformationEstimationPointToPoint(), + 200); + return result; + } + + open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target) + { + std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); + std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); + + sourceO3D->VoxelDownSample(0.01); + targetO3D->VoxelDownSample(0.01); + + std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, + open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, + open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D, + *targetO3D, + *sourceFPFHFeatures, + *targetFPFHFeatures, + false, + 0.05); + + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/registration.hh b/src/diffCheck/registration/registration.hh index 69779a72..df1e5d53 100644 --- a/src/diffCheck/registration/registration.hh +++ b/src/diffCheck/registration/registration.hh @@ -8,11 +8,49 @@ namespace diffCheck::registration{ class Registration { public: + + std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); + + /* + Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html + + Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). + point features historigrams generalize this concept by computing point features in a local neighborhood of a point, stored as higher-dimentional historigrams. + + For example, for a given point, you take all the neighboring points within a given radius, and create a complete graph on those vertices. + then for each edge of the graph you compute features that are then stored in a historigram of the original center point from which the sphere and the graph where built. + https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation proposes a simple example of such a historigram. + PCL's documentation refers to this 2009 TUM PhD thesis (but largely outside the scope of our work): https://mediatum.ub.tum.de/doc/800632/941254.pdf + + Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + */ open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); + /* + Very little information on this registration method compared to the previous one. + If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them. + https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html + */ open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target); + /* + Ransac registration based on correspondence: + Correspondances are computed between the source and target point clouds. + Then, a transformation is computed that minimizes the error between the correspondances. + If the error is above a certain threshold, the transformation is discarded and a new one is computed. - std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); + In practice, Open3D gives little information about the feature correspondence + + */ + open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target); + /* + Ransac registration based on Feature Matching + https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC + */ + open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target); + + + + }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 7273426c..503c2ed2 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -7,51 +7,170 @@ #include #include +#include +#include int main() { std::shared_ptr dfPointCloudPtr = std::make_shared(); - std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); - std::shared_ptr dfPointCloudPtrAfterReg = std::make_shared(); + std::shared_ptr dfPointCloudPtrAfterTrans_1 = std::make_shared(); + std::shared_ptr dfPointCloudPtrAfterTrans_2 = std::make_shared(); + std::shared_ptr dfPointCloudPtrAfterTrans_3 = std::make_shared(); + std::shared_ptr dfPointCloudPtrAfterTrans_4 = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\04_mesh.ply)"; + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; dfMeshPtr->LoadFromPLY(pathMesh); dfPointCloudPtr->LoadFromPLY(pathCloud); + // add noise to dfPointCloudPtr + for (int i = 0; i < dfPointCloudPtr->Points.size(); i++) + { + dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01; + } + + std::vector timesFGRFeatureMatching; + std::vector timesFGRCorrespondance; + std::vector timesRansacCorrespondance; + std::vector timesRansacFeatureMatching; + + std::vector errorsFGRFeatureMatching; + std::vector errorsFGRCorrespondance; + std::vector errorsRansacCorrespondance; + std::vector errorsRansacFeatureMatching; +int iterations = 50; + // populate the mesh with points and store it in dfPointCloudPtrGroundTruth dfPointCloudPtrGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(100000)); - // create a rigid rotation matrix - Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); - T.block<3, 3>(0, 0) = Eigen::AngleAxisd(3 , Eigen::Vector3d::UnitZ()).toRotationMatrix(); // Yes, Pi = 3 in this world - T(0, 3) = 10; - T(1, 3) = -40; + std::vector transformations; + for (int i = 0; i < iterations; i++) + { + // create a rigid rotation matrix + Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); + T.block<3, 3>(0, 0) = Eigen::AngleAxisd(0.3*i, Eigen::Vector3d::UnitX()).toRotationMatrix(); + T(0, 3) = 30 * i; + T(1, 3) = -40 * i; + T(2, 3) = 60 * i; + transformations.push_back(T); + } + + + for (int i = 0; i < iterations; i++) + { + std::shared_ptr o3DPointCloud = dfPointCloudPtr->Cvt2O3DPointCloud(); + + std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(o3DPointCloud->Transform(transformations[i])); + dfPointCloudPtrAfterTrans_1 = std::make_shared(); + dfPointCloudPtrAfterTrans_2 = std::make_shared(); + dfPointCloudPtrAfterTrans_3 = std::make_shared(); + dfPointCloudPtrAfterTrans_4 = std::make_shared(); + + dfPointCloudPtrAfterTrans_1->Cvt2DFPointCloud(o3DPointCloudAfterTrans); + dfPointCloudPtrAfterTrans_2->Cvt2DFPointCloud(o3DPointCloudAfterTrans); + dfPointCloudPtrAfterTrans_3->Cvt2DFPointCloud(o3DPointCloudAfterTrans); + dfPointCloudPtrAfterTrans_4->Cvt2DFPointCloud(o3DPointCloudAfterTrans); - std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(dfPointCloudPtr->Cvt2O3DPointCloud()->Transform(T)); - dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); std::shared_ptr reg = std::make_shared(); - //auto result = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtr); - auto result = reg->O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtr); - - // apply the transformation to the source point cloud - Eigen::Matrix transformation = result.transformation_; - std::shared_ptr o3DPointCloudPtrAfterReg = std::make_shared(dfPointCloudPtrAfterTrans->Cvt2O3DPointCloud()->Transform(transformation)); - dfPointCloudPtrAfterReg->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg); - std::vector errors = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg, dfPointCloudPtrGroundTruth); - std::cout << "Mean distance: " << std::accumulate(errors.begin(), errors.end(), 0.0) / errors.size() << std::endl; - - std::shared_ptr vis = std::make_shared(); - vis->AddPointCloud(dfPointCloudPtrGroundTruth); - vis->AddPointCloud(dfPointCloudPtrAfterReg); - vis->AddMesh(dfMeshPtr); - vis->Run(); + + // Testing the Fast Global Registration on Feature Matching method + std::shared_ptr dfPointCloudPtrAfterReg_1 = std::make_shared(); + clock_t start_1 = clock(); + auto result_1 = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans_1, dfPointCloudPtr); + double _intermediate_time_1 = (clock() - start_1) / (double) CLOCKS_PER_SEC; + timesFGRFeatureMatching.push_back(_intermediate_time_1); + Eigen::Matrix transformation = result_1.transformation_; + std::shared_ptr o3DPointCloudPtrAfterReg_1 = std::make_shared(dfPointCloudPtrAfterTrans_1->Cvt2O3DPointCloud()->Transform(transformation)); + dfPointCloudPtrAfterReg_1->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_1); + std::vector errors_1 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_1, dfPointCloudPtrGroundTruth); + errorsFGRFeatureMatching.push_back(std::accumulate(errors_1.begin(), errors_1.end(), 0.0) / errors_1.size()); + + // Testing the Fast Global Registration on Correspondance method + std::shared_ptr dfPointCloudPtrAfterReg_2 = std::make_shared(); + clock_t start_2 = clock(); + auto result_2 = reg->O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_2, dfPointCloudPtr); + double _intermediate_time_2 = (clock() - start_2) / (double) CLOCKS_PER_SEC; + timesFGRCorrespondance.push_back(_intermediate_time_2); + Eigen::Matrix transformation_2 = result_2.transformation_; + std::shared_ptr o3DPointCloudPtrAfterReg_2 = std::make_shared(dfPointCloudPtrAfterTrans_2->Cvt2O3DPointCloud()->Transform(transformation_2)); + dfPointCloudPtrAfterReg_2->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_2); + std::vector errors_2 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_2, dfPointCloudPtrGroundTruth); + errorsFGRCorrespondance.push_back(std::accumulate(errors_2.begin(), errors_2.end(), 0.0) / errors_2.size()); + + // Testing the Ransac registration based on correspondance method + std::shared_ptr dfPointCloudPtrAfterReg_3 = std::make_shared(); + clock_t start_3 = clock(); + auto result_3 = reg->O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans_3, dfPointCloudPtr); + double _intermediate_time_3 = (clock() - start_3) / (double) CLOCKS_PER_SEC; + timesRansacCorrespondance.push_back(_intermediate_time_3); + Eigen::Matrix transformation_3 = result_3.transformation_; + std::shared_ptr o3DPointCloudPtrAfterReg_3 = std::make_shared(dfPointCloudPtrAfterTrans_3->Cvt2O3DPointCloud()->Transform(transformation_3)); + dfPointCloudPtrAfterReg_3->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_3); + std::vector errors_3 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_3, dfPointCloudPtrGroundTruth); + errorsRansacCorrespondance.push_back(std::accumulate(errors_3.begin(), errors_3.end(), 0.0) / errors_3.size()); + + // Testing the Ransac registration based on Feature Matching method + std::shared_ptr dfPointCloudPtrAfterReg_4 = std::make_shared(); + clock_t start_4 = clock(); + auto result_4 = reg->O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans_4, dfPointCloudPtr); + double _intermediate_time_4 = (clock() - start_4) / (double) CLOCKS_PER_SEC; + timesRansacFeatureMatching.push_back(_intermediate_time_4); + Eigen::Matrix transformation_4 = result_4.transformation_; + std::shared_ptr o3DPointCloudPtrAfterReg_4 = std::make_shared(dfPointCloudPtrAfterTrans_4->Cvt2O3DPointCloud()->Transform(transformation_4)); + dfPointCloudPtrAfterReg_4->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_4); + std::vector errors_4 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_4, dfPointCloudPtrGroundTruth); + errorsRansacFeatureMatching.push_back(std::accumulate(errors_4.begin(), errors_4.end(), 0.0) / errors_4.size()); + + std::cout<<"Iteration: "< Date: Mon, 8 Apr 2024 18:04:34 +0200 Subject: [PATCH 024/141] WIP-FLASH: need to clean and add loop but joint detector in place --- .../{xml_exporter => DF_xml_exporter}/code.py | 4 +- .../icon.png | Bin .../metadata.json | 2 +- src/gh/diffCheck/diffCheck/df_geometries.py | 16 ++ .../diffCheck/diffCheck/df_joint_detector.py | 170 ++-------------- src/gh/diffCheck/diffCheck/df_util.py | 134 +++++++++++++ src/gh/diffCheck/diffCheck/diffCheck_app.py | 182 +++++++----------- 7 files changed, 234 insertions(+), 274 deletions(-) rename src/gh/components/{xml_exporter => DF_xml_exporter}/code.py (92%) rename src/gh/components/{xml_exporter => DF_xml_exporter}/icon.png (100%) rename src/gh/components/{xml_exporter => DF_xml_exporter}/metadata.json (98%) create mode 100644 src/gh/diffCheck/diffCheck/df_util.py diff --git a/src/gh/components/xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py similarity index 92% rename from src/gh/components/xml_exporter/code.py rename to src/gh/components/DF_xml_exporter/code.py index 69be3030..a9acc888 100644 --- a/src/gh/components/xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -15,10 +15,10 @@ from ghpythonlib.componentbase import executingcomponent as component -from diffCheck.df_geometries import DFBeam, DFAssembly +from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly -class XMLExporter(component): +class DFXMLExporter(component): def RunScript(self, i_dump : bool, i_export_dir : str, diff --git a/src/gh/components/xml_exporter/icon.png b/src/gh/components/DF_xml_exporter/icon.png similarity index 100% rename from src/gh/components/xml_exporter/icon.png rename to src/gh/components/DF_xml_exporter/icon.png diff --git a/src/gh/components/xml_exporter/metadata.json b/src/gh/components/DF_xml_exporter/metadata.json similarity index 98% rename from src/gh/components/xml_exporter/metadata.json rename to src/gh/components/DF_xml_exporter/metadata.json index 438b6f20..d805390c 100644 --- a/src/gh/components/xml_exporter/metadata.json +++ b/src/gh/components/DF_xml_exporter/metadata.json @@ -1,5 +1,5 @@ { - "name": "Exporter to xml", + "name": "DFXMLExporter", "nickname": "XMLout", "category": "diffCheck", "subcategory": "Utility", diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 631b27c8..17889de5 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -27,6 +27,9 @@ def __post_init__(self): def __repr__(self): return f"Vertex: X={self.x}, Y={self.y}, Z={self.z}" + def from_rg_point3d(point: rg.Point3d): + return DFVertex(point.X, point.Y, point.Z) + @dataclass class DFFace: @@ -47,6 +50,19 @@ def __post_init__(self): def __repr__(self): return f"Face vertices: {len(self.vertices)}" + @staticmethod + def compute_mass_center(face: rg.BrepFace) -> rg.Point3d: + """ + Compute the mass center of a face + + :param face: The face to compute the mass center from + :return mass_center: The mass center of the face + """ + amp = rg.AreaMassProperties.Compute(face) + if amp: + return amp.Centroid + return None + @property def is_joint(self): if self.joint_id: diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index 40b25fee..64c2c0a0 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -1,100 +1,22 @@ -import rhinoscriptsyntax as rs -import Rhino as rc +import Rhino import scriptcontext as sc import Rhino.Geometry as rg -import datetime as dt -import math -import log -import hole -import cut -import util +import typing -# import visual_debug as vd +import df_util -def get_lowest_brep_vertex(brep): - """ Get the the vertex with the lowest y,x and z values """ - biggest_vertices = brep.Vertices - lowest_x = 0 - lowest_y = 0 - lowest_z = 0 - for vertex in biggest_vertices: - if vertex.Location.X < lowest_x: - lowest_x = vertex.Location.X - if vertex.Location.Y < lowest_y: - lowest_y = vertex.Location.Y - if vertex.Location.Z < lowest_z: - lowest_z = vertex.Location.Z - return rc.Geometry.Point3d(lowest_x, lowest_y, lowest_z) - -def pln_2_pln_world_transform(brep): - """ Transform a brep to the world plane """ - print("Computing Oriented Bounding Boxes...") - - # find the longest edge of the brep - edges = brep.Edges - longest_edge = None - longest_edge_length = 0 - for edge in edges: - if edge.GetLength() > longest_edge_length: - longest_edge_length = edge.GetLength() - longest_edge = edge - - # find biggest face - face_indices = longest_edge.AdjacentFaces() - faces = [brep.Faces[face_index] for face_index in face_indices] - biggest_face = None - biggest_face_area = 0 - for face in faces: - if rg.AreaMassProperties.Compute(face).Area > biggest_face_area: - biggest_face_area = rg.AreaMassProperties.Compute(face).Area - biggest_face = face - - # get the plane of the biggest face - if biggest_face.TryGetPlane()[0] is False: - print("Could not find plane for longest edge. Exiting...") - return - plane_src = biggest_face.TryGetPlane()[1] - plane_tgt = rc.Geometry.Plane.WorldXY - print("Found plane for longest edge: " + str(plane_src)) - - # plane to plane transformation - plane_to_world = rc.Geometry.Transform.PlaneToPlane(plane_src, plane_tgt) - brep.Transform(plane_to_world) - - # adjust to x,y,z positive - lowest_vertex = get_lowest_brep_vertex(brep) - lowest_vertex_transform = rc.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) - brep.Transform(lowest_vertex_transform) - - bbox = brep.GetBoundingBox(True) - bbox_corners = bbox.GetCorners() - y_val_sum = 0 - x_val_sum = 0 - for corner in bbox_corners: - y_val_sum += corner.Y - x_val_sum += corner.X - - if x_val_sum > y_val_sum: - print("Bounding box is alligned to x axis. No rotation needed.") - else: - print("Bounding box is not alligned to y axis. A 90 deg rotation is needed.") - rot_90_z = rc.Geometry.Transform.Rotation(math.radians(90), rg.Vector3d.ZAxis, rg.Point3d.Origin) - brep.Transform(rot_90_z) - lowest_vertex = get_lowest_brep_vertex(brep) - - lowest_vertex_transform = rc.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) - brep.Transform(lowest_vertex_transform) - - # vd.addBrep(brep, clr=(255, 0, 0, 30)) - -def distinguish_holes_cuts(breps): +def distinguish_holes_cuts(breps) -> typing.Tuple[typing.List[Rhino.Geometry.Brep], typing.List[Rhino.Geometry.Brep]]: """ Analyse the result breps from the boolean difference operation and distinguish between holes and cuts + + :param breps: list of breps + :return: holes and cuts breps """ is_hole = False is_cut = False + is_tenon_mortise = False is_mix = False holes_b = [] cuts_b = [] @@ -109,7 +31,8 @@ def distinguish_holes_cuts(breps): if not f.IsPlanar(): is_cut = False is_hole = True - b_faces = util.explode_brep(b) + + b_faces = df_util.explode_brep(b) for b_face in b_faces: if b_face.Faces[0].IsPlanar(): b_face_edges = b_face.Edges @@ -145,7 +68,7 @@ def distinguish_holes_cuts(breps): # (5) check if closed, if it is # ---------------------- # (1) explode - faces_b = util.explode_brep(b) + faces_b = df_util.explode_brep(b) # (2) seperate in tow list flat surfaces (cuts + cylinder's bases) and non flat surfaces (cylinders) flat_faces_b = [] @@ -160,8 +83,8 @@ def distinguish_holes_cuts(breps): 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 = rc.Geometry.Brep.CreateBooleanUnion(flat_faces_b, sc.doc.ModelAbsoluteTolerance) - non_flat_faces_b = rc.Geometry.Brep.CreateBooleanUnion(non_flat_faces_b, sc.doc.ModelAbsoluteTolerance) + 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] @@ -183,70 +106,3 @@ def distinguish_holes_cuts(breps): holes_b.append(f_b) return holes_b, cuts_b - -def main(): - - # vd.set_on() - # print(vd.__IS_VDEBUG__) - - print(".acim exporter started") - rh_doc_path = rs.DocumentPath() - timestamp = dt.datetime.now().strftime("%Y%m%d_%H%M%S") - acim_path = rh_doc_path + timestamp - print("Creating ACIM file at: " + acim_path) - ACIM = acim.ACIM(acim_path) - - pieces = rs.GetObjects("Select pieces to be exported", rs.filter.polysurface, preselect=True) - if not pieces: - print("No pieces selected. Exiting...") - return - print("Selected " + str(len(pieces)) + " pieces.") - - for p_GUID in pieces: - print("Processing piece: " + str(p_GUID)) - ACIM.add_timber(str(p_GUID)) - ACIM.add_timber_state(str(p_GUID), 0) - brep = rs.coercebrep(p_GUID) - - # transform to world plane - pln_2_pln_world_transform(brep) - - # compute the bounding box - bbox = brep.GetBoundingBox(True) - bbox_b = bbox.ToBrep() - ACIM.add_bbox(str(p_GUID), bbox.GetCorners()) - - # boolean difference between the bounding box and the brep transformed - brep_result = rc.Geometry.Brep.CreateBooleanDifference(bbox_b, brep, sc.doc.ModelAbsoluteTolerance) - if brep_result is None or len(brep_result) == 0: - log.error("No breps found after boolean difference. Exiting...") - return - - # get holes and cuts breps - holes_b, cuts_b = distinguish_holes_cuts(brep_result) - print("Found:\n" \ - + "\t --holes: " + str(len(holes_b)) + "\n" \ - + "\t --cuts: " + str(len(cuts_b)) + "\n") - - # analyse and loading holes and cuts into .acim - if holes_b.__len__() != 0: - for hole_b in holes_b: - # vd.addBrep(hole_b, clr=(255, 255, 0, 30)) - print("Processing hole: " + str(hole_b)) - hole.parse_data_from_brep(ACIM, str(p_GUID), hole_b, bbox_b) - - if cuts_b.__len__() != 0: - cut_counter = 1 - for cut_b in cuts_b: - # vd.addBrep(cut_b, clr=(255, 0, 255, 30)) - print("Processing cut: " + str(cut_b)) - cut.parse_data_from_brep(ACIM, str(p_GUID), cut_b, bbox_b) - - # vd.addSingleDot(cut_b.GetBoundingBox(True).Center, str(cut_counter), (0,0,255)) - cut_counter += 1 - - sc.doc.Views.Redraw() - ACIM.dump_data() - -if __name__ == '__main__': - main() \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_util.py b/src/gh/diffCheck/diffCheck/df_util.py new file mode 100644 index 00000000..bae262c9 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_util.py @@ -0,0 +1,134 @@ +import Rhino +import Rhino.Geometry as rg +import rhinoscriptsyntax as rs +import scriptcontext as sc + +import typing + + +def explode_brep(brep) -> typing.List[Rhino.Geometry.Brep]: + """ Explode a brep into its faces """ + exploded_objects = [] + if brep.IsSolid: + for face in brep.Faces: + face_brep = face.DuplicateFace(False) + if face_brep: + exploded_objects.append(face_brep) + else: + for face in brep.Faces: + face_brep = face.DuplicateFace(False) + if face_brep: + exploded_objects.append(face_brep) + return exploded_objects + +def get_crv_circle_center(crv) -> rg.Point3d: + """ Get the center of a circle """ + bbox = crv.GetBoundingBox(True) + bbox_b = bbox.ToBrep() + center_point = bbox_b.GetBoundingBox(True).Center + return center_point + +def is_pt_unique_in_dict(pt, pt_dict) -> bool: + """ + Detect if the point exists in the dictionary, and if so, return the index + + :param pt: the point to check + :param pt_dict: the dictionary to check + :return: True if the point is unique, False otherwise + """ + is_unique = True + for pt_dict in pt_dict.keys(): + X_a = round(pt.X, 3) + Y_a = round(pt.Y, 3) + Z_a = round(pt.Z, 3) + + X_b = round(pt_dict.X, 3) + Y_b = round(pt_dict.Y, 3) + Z_b = round(pt_dict.Z, 3) + + if X_a == X_b and Y_a == Y_b and Z_a == Z_b: + is_unique = False + break + return is_unique + +def is_pt_unique_in_list(pt, list) -> bool: + """ + Detect if the point exists in the list, and if so, return the index + + :param pt: the point to check + :param list: the list to check + :return: True if the point is unique, False otherwise + """ + is_unique = True + for pt_list in list: + X_a = round(pt.X, 3) + Y_a = round(pt.Y, 3) + Z_a = round(pt.Z, 3) + + X_b = round(pt_list.X, 3) + Y_b = round(pt_list.Y, 3) + Z_b = round(pt_list.Z, 3) + + if X_a == X_b and Y_a == Y_b and Z_a == Z_b: + is_unique = False + break + return is_unique + +def detect_idx_pt_in_list(pt, list) -> int: + """ + Detect the index of a point in a list + + :param pt: the point to check + :param list: the list to check + :return: the index of the point in the list + """ + idx = -1 + for pt_list in list: + idx += 1 + X_a = round(pt.X, 3) + Y_a = round(pt.Y, 3) + Z_a = round(pt.Z, 3) + + X_b = round(pt_list.X, 3) + Y_b = round(pt_list.Y, 3) + Z_b = round(pt_list.Z, 3) + + if X_a == X_b and Y_a == Y_b and Z_a == Z_b: + return idx + return idx + +def compute_ordered_vertices(brep_face) -> typing.List[Rhino.Geometry.Point3d]: + """ Retrieve the ordered vertices of a brep face """ + sorted_vertices = [] + + edges = brep_face.DuplicateEdgeCurves() + edges = list(set(edges)) + + edges_sorted = [] + while len(edges) > 0: + if len(edges_sorted) == 0: + edges_sorted.append(edges[0]) + edges.pop(0) + else: + for edge in edges: + if edges_sorted[-1].PointAtStart == edge.PointAtStart: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + elif edges_sorted[-1].PointAtStart == edge.PointAtEnd: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + elif edges_sorted[-1].PointAtEnd == edge.PointAtStart: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + elif edges_sorted[-1].PointAtEnd == edge.PointAtEnd: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + + for edge in edges_sorted: + sorted_vertices.append(edge.PointAtStart) + + return sorted_vertices \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index f9d5d644..ba728213 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -6,113 +6,10 @@ import os import typing -from df_geometries import DFBeam, DFAssembly # diffCheck. +from df_geometries import DFVertex, DFFace, DFBeam, DFAssembly # diffCheck. import df_transformations # diffCheck. - - - - - # vd.addBrep(brep, clr=(255, 0, 0, 30)) - - -def distinguish_holes_cuts(breps) -> typing.Tuple[typing.List[Rhino.Geometry.Brep], typing.List[Rhino.Geometry.Brep]]: - """ - Analyse the result breps from the boolean difference operation - and distinguish between holes and cuts - - :param breps: list of breps - :return: holes and cuts breps - """ - is_hole = False - is_cut = False - is_mix = False - holes_b = [] - cuts_b = [] - mix_b = [] - - # parse holes, cuts and mix - for b in breps: - 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 = 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: - holes_b.append(b) - elif is_cut: - cuts_b.append(b) - elif is_mix: - mix_b.append(b) - - is_hole = False - is_cut = False - is_mix = False - - # deal with mix - candidate_cuts = [] - candidate_holes = [] - for b in mix_b: - # -- 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 = 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: - cuts_b.append(f_b) - for f_b in non_flat_faces_b: - if f_b is not None: - if f_b.IsSolid: - holes_b.append(f_b) - - return holes_b, cuts_b +import df_joint_detector # diffCheck. +import df_util # diffCheck. if __name__ == "__main__": @@ -120,20 +17,20 @@ def distinguish_holes_cuts(breps) -> typing.Tuple[typing.List[Rhino.Geometry.Bre print("Running diffCheck...") x_form = df_transformations.pln_2_pln_world_transform(i_brep) - # transformation to matrix - i_brep_copy.Transform(x_form) - # reverse the transformation x_form_back = df_transformations.get_inverse_transformation(x_form) # i_brep.Transform(x_form_back) - - - o_brep = i_brep + # o_brep = i_brep - # compute the bounding box + # compute the bounding box and inflate to include butt joints typo bbox = i_brep.GetBoundingBox(True) + diagonal = bbox.Diagonal + scaling_factor = diagonal.Length / 10 + bbox.Inflate( + scaling_factor, 0, 0 + ) bbox_b = bbox.ToBrep() print("Bounding box computed...") @@ -143,15 +40,72 @@ def distinguish_holes_cuts(breps) -> typing.Tuple[typing.List[Rhino.Geometry.Bre print("No breps found after boolean difference. Exiting...") # return + ################################################################## + ################################################################## # distinguish holes and cuts - holes_b, cuts_b = distinguish_holes_cuts(brep_result) + holes_b, cuts_b = df_joint_detector.distinguish_holes_cuts(brep_result) + # retransform back everything for b in holes_b: b.Transform(x_form_back) for b in cuts_b: b.Transform(x_form_back) + i_brep.Transform(x_form_back) + + # parse into DFFaces with detection of + # - wether it is a joint (bool) + # - if it is a hole, which one is (id) + + df_faces = [] + all_faces_centroids : typing.List[rg.Point3d] = [] + cuts_faces_centroids : typing.Dict[int, typing.List[rg.Point3d]] = {} + detected_facesjoint_centroids : typing.List[rg.Point3d] = [] + side_faces_centroids : typing.List[rg.Point3d] = [] + + # get all the medians of the faces of cuts_b + for idx, b in enumerate(cuts_b): + temp_face_centroids = [] + for f in b.Faces: + centroid = DFFace.compute_mass_center(f) + temp_face_centroids.append(centroid) + cuts_faces_centroids[idx] = temp_face_centroids + + print(f"Detected faces: {list(cuts_faces_centroids.values()).__len__()}") + tol = sc.doc.ModelAbsoluteTolerance + + breps = [i_brep] + for b in breps: + for f in b.Faces: + centroid_2test = DFFace.compute_mass_center(f) + all_faces_centroids.append(centroid_2test) + + for idx, centroids in cuts_faces_centroids.items(): + for centroid in centroids: + if centroid_2test.DistanceTo(centroid) < tol: + df_vertices = [] + face_loop = f.OuterLoop + face_loop_trims = face_loop.Trims + for face_loop_trim in face_loop_trims: + df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) + df_faces.append(DFFace(df_vertices, idx)) + detected_facesjoint_centroids.append(centroid_2test) + break + else: + df_vertices = [] + face_loop = f.OuterLoop + face_loop_trims = face_loop.Trims + for face_loop_trim in face_loop_trims: + df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) + df_faces.append(DFFace(df_vertices)) + side_faces_centroids.append(centroid_2test) o_brep = cuts_b + + o_centroids1 = side_faces_centroids + o_centroids2 = detected_facesjoint_centroids + + # beams + beam = DFBeam("Beam1", df_faces) ################################################################## # """ From 096cadf512dd5ba485e65cb3bec3a1fa2bd26443 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 8 Apr 2024 23:15:21 +0200 Subject: [PATCH 025/141] CAP: proper first draft of joint detector --- src/gh/diffCheck/diffCheck/df_cut.py | 130 ---- src/gh/diffCheck/diffCheck/df_geometries.py | 23 +- src/gh/diffCheck/diffCheck/df_hole.py | 241 ------- .../diffCheck/diffCheck/df_joint_detector.py | 265 +++++--- src/gh/diffCheck/diffCheck/diffCheck_app.py | 138 +--- src/gh/tester.ghx | 635 ++++++++++++++++-- 6 files changed, 767 insertions(+), 665 deletions(-) delete mode 100644 src/gh/diffCheck/diffCheck/df_cut.py delete mode 100644 src/gh/diffCheck/diffCheck/df_hole.py diff --git a/src/gh/diffCheck/diffCheck/df_cut.py b/src/gh/diffCheck/diffCheck/df_cut.py deleted file mode 100644 index a1793266..00000000 --- a/src/gh/diffCheck/diffCheck/df_cut.py +++ /dev/null @@ -1,130 +0,0 @@ -import Rhino as rc -import Rhino.Geometry as rg -import rhinoscriptsyntax as rs -import scriptcontext as sc - -import log -import util -import acim -import visual_debug as vd - -import random - -def parse_data_from_brep(ACIM, - p_GUID, - cut_b, - bbox_b): - """ - Parse data from a brep defining a cut - :param ACIM: the ACIM object to export xml - :param p_GUID: the guid of the timber - :param box_b: the brep defining the cut - :param bbox_b: the brep of the bounding box - """ - log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") - log.info("Parsing cut data..") - bbox_faces_b = util.explode_brep(bbox_b) - cut_faces_b = util.explode_brep(cut_b) - log.info("Cut faces: " + str(len(cut_faces_b))) - - acim_faces = [] - acim_edges = [] - # template dicts for faces and lines - acim_face_dict = {"face_id" : "1", # the id of the face - "exposed" : "True", # if the face is exposed - "edges" : "1 2 3", # the ids of the lines - "corners" : ["0 0 0", "1 1 1", "2 2 2"] # the coordinates of the corners - } - acim_edge_dict = {"line_id" : "1", # the id of the line - "start" : "0 0 0", # the start point of the line - "end" : "1 1 1", # the end point of the line - "exposed" : "true", # if the line is exposed - } - - # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - log.info("Detecting cut centroid..") - cut_centroid = cut_b.GetBoundingBox(True).Center - cut_centroid_str = str(cut_centroid.X) + " " + str(cut_centroid.Y) + " " + str(cut_centroid.Z) - - # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - log.info("Parsing lines..") - clr_edge = (0,0,0) - face_edges = cut_b.Edges - is_on_face = False - TEMP_line_ids = [] - TEMP_line_midpoints = [] - for i, face_edge in enumerate(face_edges): - acim_edge_dict["line_id"] = str(i) - acim_edge_dict["start"] = str(face_edge.PointAtStart.X) + " " + str(face_edge.PointAtStart.Y) + " " + str(face_edge.PointAtStart.Z) - acim_edge_dict["end"] = str(face_edge.PointAtEnd.X) + " " + str(face_edge.PointAtEnd.Y) + " " + str(face_edge.PointAtEnd.Z) - - face_edge_center = face_edge.PointAtNormalizedLength(0.5) - if bbox_b.IsPointInside(face_edge_center, sc.doc.ModelAbsoluteTolerance, True): - is_on_face = False - clr_edge = (0,255,0) - else: - is_on_face = True - clr_edge = (255,0,0) - acim_edge_dict["exposed"] = str(is_on_face) - - acim_edges.append(acim_edge_dict.copy()) - - vd.addPtName(face_edge.PointAtStart, str(i), clr_edge) - vd.addLine(rg.Line(face_edge.PointAtStart, face_edge.PointAtEnd), clr_edge) - - TEMP_line_ids.append(i) - TEMP_line_midpoints.append(face_edge_center) - - # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - log.info("Parsing faces..") - clr_face = (0,0,0) - for i, face in enumerate(cut_faces_b): - edges_candidate_ids = [] - acim_face_dict["face_id"] = str(i) - - face_edges = face.Edges - is_on_face = False - - # corners - corners = util.compute_ordered_vertices(face) - corners_str = [] - for corner in corners: - corners_str.append(str(corner.X) + " " + str(corner.Y) + " " + str(corner.Z)) - acim_face_dict["corners"] = corners_str - - # edges indices - for i, face_edge in enumerate(face_edges): - face_edge_center = face_edge.PointAtNormalizedLength(0.5) - idx = util.detect_idx_pt_in_list(face_edge_center, TEMP_line_midpoints) - if idx != -1: - edges_candidate_ids.append(TEMP_line_ids[idx]) - vertex = face_edge.PointAtStart - acim_face_dict["edges"] = " ".join(str(x) for x in edges_candidate_ids) - - # face exposed value - polyline_corners = corners - polyline_corners.append(corners[0]) - polyline = rg.Polyline(corners) - # vd.addPolyline(polyline, (0,0,0)) - face_center = polyline.CenterPoint() - # log.info("Face center: " + str(face_center)) - # vd.addBrep(bbox_b, (0,0,0)) - if bbox_b.IsPointInside(face_center, sc.doc.ModelAbsoluteTolerance, True): - is_on_face = False - clr_face = (0,255,0) - else: - is_on_face = True - clr_face = (255,0,0) - vd.addPtName(face_center, acim_face_dict["edges"], clr_face) - acim_face_dict["exposed"] = str(is_on_face) - - acim_faces.append(acim_face_dict.copy()) - - # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - log.info("Dumping cut in acim..") - ACIM.add_cut( - p_GUID, - cut_centroid_str, - acim_edges, - acim_faces - ) diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 17889de5..911733ad 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -10,6 +10,8 @@ import xml.etree.ElementTree as ET from xml.dom.minidom import parseString +from df_joint_detector import JointDetector + @dataclass class DFVertex: @@ -85,11 +87,6 @@ class DFBeam: faces : typing.List[DFFace] def __post_init__(self): self.name = self.name or "Unnamed Beam" - - try: - self.faces = list(self.faces) - except TypeError: - raise ValueError("Faces must be of type List[Face]") self.faces = self.faces or [] self.__id = uuid.uuid4().int @@ -97,21 +94,9 @@ def __post_init__(self): @classmethod def from_brep(cls, brep): """ - Create a Beam from a RhinoBrep object + Create a DFBeam from a RhinoBrep object """ - faces : typing.List[DFFace] = [] - brep_faces = brep.Faces - for brep_face in brep_faces: - vertices = [] - face_loop = brep_face.OuterLoop - face_loop_trims = face_loop.Trims - vertices : typing.List[DFVertex] = [] - for face_loop_trim in face_loop_trims: - vertices.append(DFVertex( - face_loop_trim.Edge.PointAtStart.X, - face_loop_trim.Edge.PointAtStart.Y, - face_loop_trim.Edge.PointAtStart.Z)) - faces.append(DFFace(vertices)) + faces = JointDetector(brep).run() beam = cls("Beam", faces) return beam diff --git a/src/gh/diffCheck/diffCheck/df_hole.py b/src/gh/diffCheck/diffCheck/df_hole.py deleted file mode 100644 index 95f9adc5..00000000 --- a/src/gh/diffCheck/diffCheck/df_hole.py +++ /dev/null @@ -1,241 +0,0 @@ -import Rhino as rc -import Rhino.Geometry as rg -import rhinoscriptsyntax as rs -import scriptcontext as sc -import random - -import log -import acim -import visual_debug as vd -import util - - -def _get_radius_from_curved_brep_faces(cylinder_faces_b, start_pt, end_pt): - for face in cylinder_faces_b: - if not face.Faces[0].IsPlanar(): - face_curves = face.DuplicateEdgeCurves(True) - face_crv = face_curves[0] - pt_base = face_crv.PointAtStart - axis_ln = rg.Line(start_pt, end_pt) - radius = axis_ln.DistanceTo(pt_base, False) - radius = round(radius, 3) - log.info("radius: " + str(radius)) - return round(radius, 3) - -def _get_single_face_brep_center(brep): - bbox = brep.GetBoundingBox(True) - bbox_b = bbox.ToBrep() - center_point = bbox_b.GetBoundingBox(True).Center - return center_point - -def parse_data_from_brep(ACIM, - p_GUID, - cylinder_b, - bbox_b): - """ - Parse data from a brep defining a hole - :param ACIM: the ACIM object to export xml - :param p_GUID: the guid of the timber - :param cylinder_b: the brep defining the hole - :param bbox_b: the brep of the bounding box - """ - log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") - bbox_faces_b = util.explode_brep(bbox_b) - cylinder_faces_b = util.explode_brep(cylinder_b) - log.info("cylinder faces: " + str(len(cylinder_faces_b))) - # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - # get the centers of the cylinder's bases and if they are exposed - acim_centers = {} - for face in cylinder_faces_b: - if face.Faces[0].IsPlanar(): - continue - face_curves = face.DuplicateEdgeCurves(True) - for face_crv in face_curves: - face_crv_center = util.get_crv_circle_center(face_crv) - is_on_face = False - if bbox_b.IsPointInside(face_crv_center, sc.doc.ModelAbsoluteTolerance, True): - if util.is_pt_unique_in_dict(face_crv_center, acim_centers): - acim_centers[face_crv_center] = is_on_face - vd.addPt(face_crv_center, (0,255,0)) - continue - if rs.IsPointOnSurface(face, face_crv_center): - is_on_face = True - if util.is_pt_unique_in_dict(face_crv_center, acim_centers): - acim_centers[face_crv_center] = is_on_face - vd.addPt(face_crv_center, (255,0,0)) - log.info("length of acim_centers: " + str(len(acim_centers))) - - # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - # parse simple holes or sub-holes - centers_len = len(acim_centers) - if centers_len == 0: - log.error("No center found for the hole. Exiting...") - return - if centers_len == 1: - log.info("Single center found for the hole. Exiting...") - return - if centers_len == 2: - log.info("Simple 2-points hole detected") - start_pt = rg.Point3d(0,0,0) - end_pt = rg.Point3d(0,0,0) - is_start_pt_accessible = False - is_end_pt_accessible = False - if acim_centers.values()[0]: - start_pt = acim_centers.keys()[0] - end_pt = acim_centers.keys()[1] - is_start_pt_accessible = acim_centers.values()[0] - is_end_pt_accessible = acim_centers.values()[1] - else: - start_pt = acim_centers.keys()[1] - end_pt = acim_centers.keys()[0] - is_start_pt_accessible = acim_centers.values()[1] - is_end_pt_accessible = acim_centers.values()[0] - - radius = _get_radius_from_curved_brep_faces(cylinder_faces_b, start_pt, end_pt) - log.info("radius: " + str(radius)) - vd.addLine(rg.Line(start_pt, end_pt), (255,165,0)) - vd.addDotPt(ptA=start_pt, ptB=end_pt, clr=(0,255,0), txt=str(ACIM.peek_current_hole_id(p_GUID))) - - for face in cylinder_faces_b: - if not face.Faces[0].IsPlanar(): - face_curves = face.DuplicateEdgeCurves(True) - vd.addCurve(face_curves[0], (255,0,255)) - vd.addCurve(face_curves[1], (255,0,255)) - - ACIM.add_hole(p_GUID, - start_pt, - end_pt, - is_start_pt_accessible, - is_end_pt_accessible, - radius) - if centers_len > 2: - log.info("Complex hole detected") - holes = [] - - # get longest line - dists = [] - extreme_pts = [] - for i in range(0, centers_len): - for j in range(i+1, centers_len): - pt1 = acim_centers.keys()[i] - pt2 = acim_centers.keys()[j] - dist = pt1.DistanceTo(pt2) - dists.append(dist) - if dist >= max(dists) or len(dists) == 0: - extreme_pts = [i, j] - - extreme_pts = [acim_centers.keys()[extreme_pts[0]], - acim_centers.keys()[extreme_pts[1]]] - longest_ln = rg.Line(extreme_pts[0], extreme_pts[1]) - longest_crv = longest_ln.ToNurbsCurve() - - centers_lst_reorder = list(acim_centers.keys()) - centers_lst_reorder.sort(key=lambda x: extreme_pts[0].DistanceTo(x)) - - #create segments - hole_axis_ln = [] - for i in range(0, centers_len-1): - pt1 = centers_lst_reorder[i] - pt2 = centers_lst_reorder[i+1] - ln = rg.Line(pt1, pt2) - hole_axis_ln.append(ln) - - # detect neighbours - neighbor_lst = [] - for i in range(0, len(hole_axis_ln)): - for j in range(0, len(hole_axis_ln)): - if i == j: - continue - if hole_axis_ln[i].DistanceTo(hole_axis_ln[j].From, False) < 0.01: - neighbor_lst.append([i, j]) - break - if hole_axis_ln[i].DistanceTo(hole_axis_ln[j].To, False) < 0.01: - neighbor_lst.append([i, j]) - break - log.info("neighbor pattern for current hole set: " + str(neighbor_lst)) - next_hole_ids = [] - current_hole_id = ACIM.peek_current_hole_id(p_GUID) - for i in range(1, len(neighbor_lst)+1): - next_hole_ids.append(current_hole_id) - current_hole_id += 1 - log.info("next hole ids: " + str(next_hole_ids)) - neighbor_acim_str = [] - for i in range(0, len(neighbor_lst)): - temp_str = "" - for j in range(1, len(neighbor_lst[i])): - temp_str += str(next_hole_ids[neighbor_lst[i][j]]) + " " - temp_str = temp_str[:-1] - neighbor_acim_str.append(temp_str) - log.info("neighbor acim str: " + str(neighbor_acim_str)) - - for i, axis_ln in enumerate(hole_axis_ln): - vd.addLine(axis_ln, (255,165,0)) - vd.addDotLn(ln=axis_ln, clr=(30,255,230), txt=str(ACIM.peek_current_hole_id(p_GUID))) - - start_pt = rg.Point3d(0,0,0) - end_pt = rg.Point3d(0,0,0) - is_start_pt_accessible = False - is_end_pt_accessible = False - pt_1 = axis_ln.PointAt(0) - pt_2 = axis_ln.PointAt(1) - if acim_centers[pt_1]: - start_pt = pt_1 - end_pt = pt_2 - is_start_pt_accessible = acim_centers[pt_1] - is_end_pt_accessible = acim_centers[pt_2] - else: - start_pt = pt_2 - end_pt = pt_1 - is_start_pt_accessible = acim_centers[pt_2] - is_end_pt_accessible = acim_centers[pt_1] - - for face in cylinder_faces_b: - if not face.Faces[0].IsPlanar(): - radius = 0 - face_curves = face.DuplicateEdgeCurves(True) - face_center_A = util.get_crv_circle_center(face_curves[0]) - face_center_B = util.get_crv_circle_center(face_curves[1]) - - vd.addCurve(face_curves[0], (255,0,255)) - vd.addCurve(face_curves[1], (255,0,255)) - - f_0X = round(face_center_A.X, 3) - f_0Y = round(face_center_A.Y, 3) - f_0Z = round(face_center_A.Z, 3) - - f_1X = round(face_center_B.X, 3) - f_1Y = round(face_center_B.Y, 3) - f_1Z = round(face_center_B.Z, 3) - - sX = round(start_pt.X, 3) - sY = round(start_pt.Y, 3) - sZ = round(start_pt.Z, 3) - - eX = round(end_pt.X, 3) - eY = round(end_pt.Y, 3) - eZ = round(end_pt.Z, 3) - - if (f_0X == sX and f_0Y == sY and f_0Z == sZ) or (f_0X == eX and f_0Y == eY and f_0Z == eZ): # = start - if (f_1X == sX and f_1Y == sY and f_1Z == sZ) or (f_1X == eX and f_1Y == eY and f_1Z == eZ): # = end - ellipse_pt = face_curves[0].PointAtStart - radius = axis_ln.DistanceTo(ellipse_pt, False) - radius = round(radius, 3) - log.info("radius: " + str(radius)) - break - - ACIM.add_hole(p_GUID, - start_pt, - end_pt, - is_start_pt_accessible, - is_end_pt_accessible, - radius, - neighbours=neighbor_acim_str[i]) - - - - - - - - - diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index 64c2c0a0..6c9db99c 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -3,106 +3,189 @@ import Rhino.Geometry as rg import typing +from dataclasses import dataclass import df_util +import df_transformations +from df_geometries import DFVertex, DFFace -def distinguish_holes_cuts(breps) -> typing.Tuple[typing.List[Rhino.Geometry.Brep], typing.List[Rhino.Geometry.Brep]]: - """ - Analyse the result breps from the boolean difference operation - and distinguish between holes and cuts - :param breps: list of breps - :return: holes and cuts breps +@dataclass +class JointDetector(): """ - is_hole = False - is_cut = False - is_tenon_mortise = False - is_mix = False - holes_b = [] - cuts_b = [] - mix_b = [] - - # parse holes, cuts and mix - for b in breps: - 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 = 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 + This class is responsible for detecting joints in a 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 : typing.List[DFFace] = [] + + def run(self) -> typing.List[DFFace]: + """ + Run the joint detector + + :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 = df_transformations.pln_2_pln_world_transform(self.brep) + + # reverse the transformation + x_form_back = df_transformations.get_inverse_transformation(x_form) - if is_hole: - holes_b.append(b) - elif is_cut: - cuts_b.append(b) - elif is_mix: - mix_b.append(b) + # 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 = 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: + 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 = 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) - # deal with mix - candidate_cuts = [] - candidate_holes = [] - for b in mix_b: - # -- 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 = 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) + # (*) 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) + 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) + self.brep.Transform(x_form_back) + + cuts_faces_centroids : typing.Dict[int, typing.List[rg.Point3d]] = {} + + # get all the medians of the faces of cuts + for idx, b in enumerate(self._cuts): + temp_face_centroids = [] + for f in b.Faces: + centroid = DFFace.compute_mass_center(f) + temp_face_centroids.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 = DFFace.compute_mass_center(f) + for idx, centroids in cuts_faces_centroids.items(): + for centroid in centroids: + if centroid_2test.DistanceTo(centroid) < sc.doc.ModelAbsoluteTolerance: + df_vertices = [] + face_loop = f.OuterLoop + face_loop_trims = face_loop.Trims + for face_loop_trim in face_loop_trims: + df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) + self._faces.append(DFFace(df_vertices, idx)) + break 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: - cuts_b.append(f_b) - for f_b in non_flat_faces_b: - if f_b is not None: - if f_b.IsSolid: - holes_b.append(f_b) - - return holes_b, cuts_b + df_vertices = [] + face_loop = f.OuterLoop + face_loop_trims = face_loop.Trims + for face_loop_trim in face_loop_trims: + df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) + self._faces.append(DFFace(df_vertices)) + + return self._faces diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index ba728213..59fc8a0e 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -11,122 +11,28 @@ import df_joint_detector # diffCheck. import df_util # diffCheck. +from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML if __name__ == "__main__": - - print("Running diffCheck...") - x_form = df_transformations.pln_2_pln_world_transform(i_brep) - - # reverse the transformation - x_form_back = df_transformations.get_inverse_transformation(x_form) - - # i_brep.Transform(x_form_back) - # o_brep = i_brep - - - # compute the bounding box and inflate to include butt joints typo - bbox = i_brep.GetBoundingBox(True) - diagonal = bbox.Diagonal - scaling_factor = diagonal.Length / 10 - bbox.Inflate( - scaling_factor, 0, 0 - ) - bbox_b = bbox.ToBrep() - - print("Bounding box computed...") - # boolean difference between the bounding box and the brep transformed - brep_result = Rhino.Geometry.Brep.CreateBooleanDifference(bbox_b, i_brep, sc.doc.ModelAbsoluteTolerance) - if brep_result is None or len(brep_result) == 0: - print("No breps found after boolean difference. Exiting...") - # return - - ################################################################## - ################################################################## - # distinguish holes and cuts - holes_b, cuts_b = df_joint_detector.distinguish_holes_cuts(brep_result) - - # retransform back everything - for b in holes_b: - b.Transform(x_form_back) - for b in cuts_b: - b.Transform(x_form_back) - i_brep.Transform(x_form_back) - - # parse into DFFaces with detection of - # - wether it is a joint (bool) - # - if it is a hole, which one is (id) - - df_faces = [] - all_faces_centroids : typing.List[rg.Point3d] = [] - cuts_faces_centroids : typing.Dict[int, typing.List[rg.Point3d]] = {} - detected_facesjoint_centroids : typing.List[rg.Point3d] = [] - side_faces_centroids : typing.List[rg.Point3d] = [] - - # get all the medians of the faces of cuts_b - for idx, b in enumerate(cuts_b): - temp_face_centroids = [] - for f in b.Faces: - centroid = DFFace.compute_mass_center(f) - temp_face_centroids.append(centroid) - cuts_faces_centroids[idx] = temp_face_centroids - - print(f"Detected faces: {list(cuts_faces_centroids.values()).__len__()}") - tol = sc.doc.ModelAbsoluteTolerance - - breps = [i_brep] - for b in breps: - for f in b.Faces: - centroid_2test = DFFace.compute_mass_center(f) - all_faces_centroids.append(centroid_2test) - - for idx, centroids in cuts_faces_centroids.items(): - for centroid in centroids: - if centroid_2test.DistanceTo(centroid) < tol: - df_vertices = [] - face_loop = f.OuterLoop - face_loop_trims = face_loop.Trims - for face_loop_trim in face_loop_trims: - df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) - df_faces.append(DFFace(df_vertices, idx)) - detected_facesjoint_centroids.append(centroid_2test) - break - else: - df_vertices = [] - face_loop = f.OuterLoop - face_loop_trims = face_loop.Trims - for face_loop_trim in face_loop_trims: - df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) - df_faces.append(DFFace(df_vertices)) - side_faces_centroids.append(centroid_2test) - - o_brep = cuts_b - - o_centroids1 = side_faces_centroids - o_centroids2 = detected_facesjoint_centroids - + """ + Main function to test the package + :param i_breps: list of breps + :param i_export_dir: directory to export the xml + :param i_dump: whether to dump the xml + """ # beams - beam = DFBeam("Beam1", df_faces) - ################################################################## - - # """ - # Main function to test the package - # :param i_breps: list of breps - # :param i_export_dir: directory to export the xml - # :param i_dump: whether to dump the xml - # """ - # # beams - # beams : typing.List[DFBeam] = [] - # for brep in i_breps: - # beam = DFBeam.from_brep(brep) - # beams.append(beam) - - # # assembly - # assembly1 = DFAssembly(beams, "Assembly1") - # print(assembly1.beams) - # print(assembly1) - - # # dump the xml - # xml : str = assembly1.to_xml() - # if i_dump: - # assembly1.dump(xml, i_export_dir) - # o_xml = xml \ No newline at end of file + beams : typing.List[DFBeam] = [] + for brep in i_breps: + beam = DFBeam.from_brep(brep) + beams.append(beam) + + # assembly + assembly1 = DFAssembly(beams, "Assembly1") + print(assembly1.beams) + print(assembly1) + + # dump the xml + xml : str = assembly1.to_xml() + if i_dump: + assembly1.dump(xml, i_export_dir) + o_xml = xml \ No newline at end of file diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index 0de0df29..a5ca3f80 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - -192 - -8 + 198 + 30 - 1.7647058 + 0.7830095 @@ -99,9 +99,9 @@ - 12 + 18 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -132,27 +132,29 @@ - 213 - 133 - 115 - 44 + 178 + 109 + 138 + 84 - 267 - 155 + 258 + 151 - - 2 + + 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 @@ -175,14 +177,14 @@ - 215 - 135 - 37 + 180 + 111 + 63 20 - 235 - 145 + 213 + 121 @@ -190,16 +192,52 @@ + true + Converts to collection of text fragments + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + e0ef2066-70a4-441f-906b-8a4afddb0692 + i_export_dir + i_export_dir + true + 0 + true + 77c76654-6be3-4843-b564-afe44705740d + 1 + + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 180 + 131 + 63 + 20 + + + 213 + 141 + + + + + + + + 1 true Converts to collection of Breps (Boundary REPresentations) iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= ae8c9c0d-8d6a-4a8c-812a-110846a2031c - i_brep - i_brep + i_breps + i_breps true - 0 + 1 true 0f309845-29e6-43ae-b255-cdb5c2d13da9 1 @@ -210,14 +248,49 @@ - 215 - 155 - 37 + 180 + 151 + 63 + 20 + + + 213 + 161 + + + + + + + + true + Converts to collection of boolean values + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 1e3c2c63-ede9-4faf-9790-a3d1b9350ba3 + i_dump + i_dump + true + 0 + true + 254a4a2f-d415-488e-9851-4a763f1ba58f + 1 + + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 180 + 171 + 63 20 - 235 - 165 + 213 + 181 @@ -244,14 +317,14 @@ - 282 - 135 - 44 - 20 + 273 + 111 + 41 + 40 - 304 - 145 + 293.5 + 131 @@ -265,8 +338,8 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== a849584f-8d8a-4547-a1a4-36be0bf3ac37 - o_brep - o_brep + o_xml + o_xml false 0 true @@ -278,14 +351,14 @@ - 282 - 155 - 44 - 20 + 273 + 151 + 41 + 40 - 304 - 165 + 293.5 + 171 @@ -295,7 +368,7 @@ - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self, btn: bool, i_brep: Rhino.Geometry.Brep):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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)
 + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_dump: bool):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -332,8 +405,8 @@ - 116 - 125 + 81 + 101 66 22 @@ -363,14 +436,14 @@ - 131 - 153 + 93 + 154 50 24 - 156.24402 - 165.29077 + 118.14979 + 166.4741 @@ -381,16 +454,28 @@ - 1 + 4 {0} - + - - - 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 - - 491fb852-545c-48e6-b8e5-8848ae2eb894 + + aa56315b-2905-4049-8c41-0cc8b39d864b + + + + + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 + + + + + 322f4e22-d195-435e-b290-052cb2318277 + + + + + 7fc04154-255a-413f-a8a1-6ea034e1e779 @@ -414,28 +499,27 @@ Panel false - 0 + 0.409473717212677 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 1 Double click to edit panel content… - + - 355 - 0 - 343 - 166 + 340 + -150 + 494 + 162 0 0 0 - 355.2232 - 0.3242798 + 340.46298 + -149.99644 - true @@ -800,7 +884,7 @@ - 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 + 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 00000000-0000-0000-0000-000000000000 @@ -808,7 +892,7 @@ - 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 + 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 00000000-0000-0000-0000-000000000000 @@ -816,7 +900,7 @@ - 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 + 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 00000000-0000-0000-0000-000000000000 @@ -1169,6 +1253,421 @@ + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 5262b483-9441-440a-a74d-8b235aad399d + true + Panel + + false + 0.027397260069847107 + a849584f-8d8a-4547-a1a4-36be0bf3ac37 + 1 + Double click to edit panel content… + + + + + + 413 + 19 + 343 + 162 + + 0 + 0 + 0 + + 413.26245 + 19.415314 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 6f2c8a4b-d787-4606-9170-900f972641c6 + Custom Preview + Preview + + + + + + + 935 + 81 + 48 + 44 + + + 969 + 103 + + + + + + Geometry to preview + true + 43f69636-7c49-4472-9329-bd25ec713d12 + Geometry + G + false + 0 + + + + + + 937 + 83 + 17 + 20 + + + 947 + 93 + + + + + + + + The material override + e22d7711-ceb9-48df-9270-b376fcd13ae6 + Material + M + false + b14c32be-c541-4fae-93c2-449d7543457e + 1 + + + + + + 937 + 103 + 17 + 20 + + + 947 + 113 + + + + + + 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 + 53c99f0b-499f-4471-9227-acc96558bfea + Custom Preview + Preview + + + + + + + 956 + 153 + 48 + 44 + + + 990 + 175 + + + + + + Geometry to preview + true + 525f46ad-33c4-44dc-8862-35b0ddce4d1d + Geometry + G + false + 0 + + + + + + 958 + 155 + 17 + 20 + + + 968 + 165 + + + + + + + + The material override + 2e7559ef-c4d5-4ffe-a304-c34c078e5af0 + Material + M + false + 0 + + + + + + 958 + 175 + 17 + 20 + + + 968 + 185 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + b14c32be-c541-4fae-93c2-449d7543457e + Colour Swatch + Swatch + false + 0 + + 255;255;255;255 + + + + + + + 834 + 103 + 88 + 20 + + + 834.6667 + 103.333336 + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 254a4a2f-d415-488e-9851-4a763f1ba58f + Button + dump! + false + 0 + + + + + + 41 + 187 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 77c76654-6be3-4843-b564-afe44705740d + File Path + Path + false + 0 + + + + + + 94 + 126 + 50 + 24 + + + 119.621796 + 138.73785 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\__TEMP\test\ + + + + + + + + + + @@ -1176,7 +1675,7 @@ - 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 + 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 From 50b2786fe84d5dad295e01543d8d389cdc2b4027 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 8 Apr 2024 23:24:16 +0200 Subject: [PATCH 026/141] FIX: updated component code --- src/gh/components/DF_xml_exporter/code.py | 3 +- .../components/DF_xml_exporter/metadata.json | 12 ++ src/gh/diffCheck/diffCheck/diffCheck_app.py | 2 +- src/gh/tester.ghx | 198 +++++++++++++----- 4 files changed, 158 insertions(+), 57 deletions(-) diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py index a9acc888..ef83315e 100644 --- a/src/gh/components/DF_xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -21,6 +21,7 @@ class DFXMLExporter(component): def RunScript(self, i_dump : bool, + i_name : str, i_export_dir : str, i_breps : typing.List[Rhino.Geometry.Brep] ): @@ -37,7 +38,7 @@ def RunScript(self, beams.append(beam) # assembly - assembly1 = DFAssembly(beams, "Assembly1") + assembly1 = DFAssembly(beams, i_name) print(assembly1.beams) print(assembly1) diff --git a/src/gh/components/DF_xml_exporter/metadata.json b/src/gh/components/DF_xml_exporter/metadata.json index d805390c..cb3b2027 100644 --- a/src/gh/components/DF_xml_exporter/metadata.json +++ b/src/gh/components/DF_xml_exporter/metadata.json @@ -25,6 +25,18 @@ "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", diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index 59fc8a0e..bcd65444 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -27,7 +27,7 @@ beams.append(beam) # assembly - assembly1 = DFAssembly(beams, "Assembly1") + assembly1 = DFAssembly(beams, i_assembly_name) print(assembly1.beams) print(assembly1) diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index a5ca3f80..e4684b08 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 198 - 30 + 87 + -98 - 0.7830095 + 2.0789368 @@ -99,9 +99,9 @@ - 18 + 19 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -132,29 +132,30 @@ - 178 - 109 - 138 - 84 + 175 + 92 + 165 + 104 - 258 - 151 + 282 + 144 - - 4 + + 5 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 2 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa - + true @@ -177,14 +178,14 @@ - 180 - 111 - 63 + 177 + 94 + 90 20 - 213 - 121 + 223.5 + 104 @@ -212,14 +213,14 @@ - 180 - 131 - 63 + 177 + 114 + 90 20 - 213 - 141 + 223.5 + 124 @@ -248,20 +249,55 @@ - 180 - 151 - 63 + 177 + 134 + 90 20 - 213 - 161 + 223.5 + 144 + + true + Converts to collection of text fragments + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + d9632669-508e-4a03-b9bc-a5d740ef546f + i_assembly_name + i_assembly_name + true + 0 + true + 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 + 1 + + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 177 + 154 + 90 + 20 + + + 223.5 + 164 + + + + + + true Converts to collection of boolean values @@ -283,14 +319,14 @@ - 180 - 171 - 63 + 177 + 174 + 90 20 - 213 - 181 + 223.5 + 184 @@ -317,14 +353,14 @@ - 273 - 111 + 297 + 94 41 - 40 + 50 - 293.5 - 131 + 317.5 + 119 @@ -351,14 +387,14 @@ - 273 - 151 + 297 + 144 41 - 40 + 50 - 293.5 - 171 + 317.5 + 169 @@ -368,7 +404,7 @@ - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_dump: bool):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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)
 + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name: str,
            i_dump: bool):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -405,8 +441,8 @@ - 81 - 101 + 80 + 79 66 22 @@ -436,14 +472,14 @@ - 93 - 154 + 92 + 132 50 24 - 118.14979 - 166.4741 + 117.58312 + 144.94077 @@ -1633,13 +1669,13 @@ 94 - 126 + 105 50 24 - 119.621796 - 138.73785 + 119.05513 + 117.20451 @@ -1668,6 +1704,58 @@ + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 44 + 161 + 102 + 20 + + 0 + 0 + 0 + + 44.200005 + 161.50002 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + @@ -1675,7 +1763,7 @@ - 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 + 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 From d8eefa6860c01abf99bcdb507490e39258d622a0 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Tue, 9 Apr 2024 15:49:59 +0200 Subject: [PATCH 027/141] WIP: working on solving tenon-mortise --- src/gh/diffCheck/diffCheck/__init__.py | 2 +- src/gh/diffCheck/diffCheck/df_geometries.py | 80 +++- .../diffCheck/diffCheck/df_joint_detector.py | 32 +- src/gh/diffCheck/diffCheck/diffCheck_app.py | 13 +- src/gh/diffCheck/setup.py | 2 +- src/gh/tester.ghx | 440 +++++++----------- 6 files changed, 282 insertions(+), 287 deletions(-) diff --git a/src/gh/diffCheck/diffCheck/__init__.py b/src/gh/diffCheck/diffCheck/__init__.py index 210ebb3e..8dbfdadd 100644 --- a/src/gh/diffCheck/diffCheck/__init__.py +++ b/src/gh/diffCheck/diffCheck/__init__.py @@ -1 +1 @@ -__version__ = '0.0.2' \ No newline at end of file +__version__ = '0.0.3' \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 911733ad..6e0f813d 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -29,8 +29,23 @@ def __post_init__(self): def __repr__(self): return f"Vertex: X={self.x}, Y={self.y}, Z={self.z}" - def from_rg_point3d(point: rg.Point3d): - return DFVertex(point.X, point.Y, point.Z) + def __hash__(self): + return hash((self.x, self.y, self.z)) + + def __eq__(self, other): + if isinstance(other, DFVertex): + return self.x == other.x and self.y == other.y and self.z == other.z + return False + + @classmethod + def from_rg_point3d(cls, point: rg.Point3d): + """ + Create a DFVertex from a Rhino Point3d object + + :param point: The Rhino Point3d object + :return vertex: The DFVertex object + """ + return cls(point.X, point.Y, point.Z) @dataclass @@ -45,13 +60,21 @@ def __post_init__(self): raise ValueError("A face must have at least 3 vertices") self.vertices = self.vertices or [] - self.joint_id = self.joint_id or None + self.joint_id = self.joint_id self.__is_joint = False self.__id = uuid.uuid4().int def __repr__(self): return f"Face vertices: {len(self.vertices)}" + def __hash__(self): + return hash((tuple(self.vertices), self.joint_id)) + + def __eq__(self, other): + if isinstance(other, DFFace): + return self.vertices == other.vertices and self.joint_id == other.joint_id + return False + @staticmethod def compute_mass_center(face: rg.BrepFace) -> rg.Point3d: """ @@ -65,9 +88,44 @@ def compute_mass_center(face: rg.BrepFace) -> rg.Point3d: return amp.Centroid return None + @classmethod + def from_brep(cls, brep_face: rg.BrepFace, joint_id: int=None): + """ + Create a DFFace from a Rhino Brep face + + :param brep_face: The Rhino Brep face + :param joint_id: The joint id + :return face: The DFFace object + """ + vertices = [] + face_loop = brep_face.OuterLoop + face_loop_trims = face_loop.Trims + + face_curve_loop = brep_face.OuterLoop.To3dCurve() + face_curve_loop = face_curve_loop.ToNurbsCurve() + face_vertices = face_curve_loop.Points + + for f_v in face_vertices: + vertex = DFVertex(f_v.X, f_v.Y, f_v.Z) + vertices.append(vertex) + + return cls(vertices, joint_id) + + def to_brep(self): + """ + Convert the face to a Rhino Brep planar face + + :return brep_face: The Rhino Brep planar face + """ + vertices : rg.Point3d = [rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in self.vertices] + polyline = rg.Polyline(vertices) + face_brep = rg.Brep.CreatePlanarBreps([polyline.ToNurbsCurve()])[0] + + return face_brep + @property def is_joint(self): - if self.joint_id: + if self.joint_id is not None: self.__is_joint = True return True self.__is_joint = False @@ -88,15 +146,19 @@ class DFBeam: def __post_init__(self): self.name = self.name or "Unnamed Beam" self.faces = self.faces or [] + self._joint_faces = [] + self._side_faces = [] self.__id = uuid.uuid4().int @classmethod def from_brep(cls, brep): """ - Create a DFBeam from a RhinoBrep object + Create a DFBeam from a RhinoBrep object. + It also removes duplicates and creates a list of unique faces. """ faces = JointDetector(brep).run() + faces = list(set(faces)) beam = cls("Beam", faces) return beam @@ -107,6 +169,14 @@ def __repr__(self): def id(self): return self.__id + @property + def joint_faces(self): + return [face for face in self.faces if face.is_joint] + + @property + def side_faces(self): + return [face for face in self.faces if not face.is_joint] + @dataclass class DFAssembly: diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index 6c9db99c..7713f2a6 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -155,12 +155,14 @@ def run(self) -> typing.List[DFFace]: 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) + # get all the medians of the faces of cuts only cuts_faces_centroids : typing.Dict[int, typing.List[rg.Point3d]] = {} - - # get all the medians of the faces of cuts for idx, b in enumerate(self._cuts): + idx = idx + 1 temp_face_centroids = [] for f in b.Faces: centroid = DFFace.compute_mass_center(f) @@ -170,22 +172,16 @@ def run(self) -> typing.List[DFFace]: # compare with the brep medians faces to get the joint/sides's faces for f in self.brep.Faces: centroid_2test = DFFace.compute_mass_center(f) - for idx, centroids in cuts_faces_centroids.items(): + for key, centroids in cuts_faces_centroids.items(): + is_joint = False for centroid in centroids: if centroid_2test.DistanceTo(centroid) < sc.doc.ModelAbsoluteTolerance: - df_vertices = [] - face_loop = f.OuterLoop - face_loop_trims = face_loop.Trims - for face_loop_trim in face_loop_trims: - df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) - self._faces.append(DFFace(df_vertices, idx)) + self._faces.append(DFFace.from_brep(f, key)) + is_joint = True break - else: - df_vertices = [] - face_loop = f.OuterLoop - face_loop_trims = face_loop.Trims - for face_loop_trim in face_loop_trims: - df_vertices.append(DFVertex.from_rg_point3d(face_loop_trim.PointAtStart)) - self._faces.append(DFFace(df_vertices)) - - return self._faces + if is_joint: + break + if not is_joint: + self._faces.append(DFFace.from_brep(f, None)) + + return self._faces \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index bcd65444..1850d9b6 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -1,4 +1,5 @@ #! python3 + import Rhino import Rhino.Geometry as rg import scriptcontext as sc @@ -35,4 +36,14 @@ xml : str = assembly1.to_xml() if i_dump: assembly1.dump(xml, i_export_dir) - o_xml = xml \ No newline at end of file + o_xml = xml + + # show the joint/side faces + joints_faces_breps = [] + sides_faces_breps = [] + for beam in beams: + joints_faces_breps.extend([face.to_brep() for face in beam.joint_faces]) + sides_faces_breps.extend([face.to_brep() for face in beam.side_faces]) + + o_joints = joints_faces_breps + o_sides = sides_faces_breps \ No newline at end of file diff --git a/src/gh/diffCheck/setup.py b/src/gh/diffCheck/setup.py index 3a3a225e..3520ee6a 100644 --- a/src/gh/diffCheck/setup.py +++ b/src/gh/diffCheck/setup.py @@ -2,7 +2,7 @@ setup( name='diffCheck', - version='0.0.2', + version='0.0.3', packages=find_packages(), description='DiffCheck is a package to check the differences between two timber structures', long_description=open('README.md').read(), diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index e4684b08..f128de26 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 87 - -98 + -12 + -118 - 2.0789368 + 1.2750002 @@ -110,9 +110,10 @@ - + true + true 2 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 @@ -134,7 +135,7 @@ 175 92 - 165 + 171 104 @@ -144,18 +145,20 @@ - + 5 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 - 2 + 4 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa - + true @@ -355,12 +358,12 @@ 297 94 - 41 - 50 + 47 + 25 - 317.5 - 119 + 320.5 + 106.5 @@ -383,18 +386,86 @@ 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + 297 + 119 + 47 + 25 + + + 320.5 + 131.5 + + + + + + + + false + No conversion + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 178951a0-3c74-4810-aef0-87cc45b0502c + o_joints + o_joints + false + 0 + true + 0 + + 6a184b65-baa3-42d1-a548-3915b401de53 + 297 144 - 41 - 50 + 47 + 25 - 317.5 + 320.5 + 156.5 + + + + + + + + false + No conversion + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 76758d37-2a1d-412d-b85b-149ecda8a020 + o_sides + o_sides + false + 0 + true + 0 + + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 297 169 + 47 + 25 + + + 320.5 + 181.5 @@ -490,28 +561,33 @@ - 4 + 5 {0} - + - aa56315b-2905-4049-8c41-0cc8b39d864b + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 - ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 + 7fc04154-255a-413f-a8a1-6ea034e1e779 - 322f4e22-d195-435e-b290-052cb2318277 + aa56315b-2905-4049-8c41-0cc8b39d864b - 7fc04154-255a-413f-a8a1-6ea034e1e779 + 322f4e22-d195-435e-b290-052cb2318277 + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 @@ -535,7 +611,7 @@ Panel false - 0.409473717212677 + 0 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 1 Double click to edit panel content… @@ -544,17 +620,17 @@ - 340 - -150 + 329 + -243 494 - 162 + 292 0 0 0 - 340.46298 - -149.99644 + 329.48257 + -242.18234 @@ -1039,204 +1115,6 @@ - - 719467e6-7cf5-4848-99b0-c5dd57e5442c - 066d0a87-236f-4eae-a0f4-9e42f5327962 - Python 3 Script - - - - - - true - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== - - 692eaddb-c313-4649-8d06-bb4758e34447 - true - true - true - Python 3 Script - Py3 - - false - false - true - - - - - - 257 - 224 - 72 - 44 - - - 286 - 246 - - - - - - 2 - 08908df5-fa14-4982-9ab2-1aa0927566aa - 08908df5-fa14-4982-9ab2-1aa0927566aa - 2 - 3ede854e-c753-40eb-84cb-b48008f14fd4 - 08908df5-fa14-4982-9ab2-1aa0927566aa - - - - - true - No conversion - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - - 47ff6ae7-24ce-4f29-823d-93afd6bb4c78 - x - x - true - 0 - true - 0 - - 6a184b65-baa3-42d1-a548-3915b401de53 - - - - - - 259 - 226 - 12 - 20 - - - 266.5 - 236 - - - - - - - - true - No conversion - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - - abe1ba7e-2994-43d0-9af7-cb2aaaa3f7c0 - y - y - true - 0 - true - 0 - - 6a184b65-baa3-42d1-a548-3915b401de53 - - - - - - 259 - 246 - 12 - 20 - - - 266.5 - 256 - - - - - - - - The execution information, as output and error streams - 155841e4-9095-4931-9b41-7d9131e024c3 - out - out - false - 0 - - - - - - 301 - 226 - 26 - 20 - - - 314 - 236 - - - - - - - - false - No conversion - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - - 127d1297-1eba-4798-aaa2-01a05a1b95d6 - a - a - false - 0 - true - 0 - - 6a184b65-baa3-42d1-a548-3915b401de53 - - - - - - 301 - 246 - 26 - 20 - - - 314 - 256 - - - - - - - - - - aW1wb3J0IG9zDQoNCnBhdGggPSByIkY6XGRpZmZDaGVja1xzcmNcZ2hcZGlmZkNoZWNrXGRpZmZDaGVja19hcHAucHkiDQpwYXRoX2RpciA9IG9zLnBhdGguZGlybmFtZShwYXRoKQ0Kc3ViX2RpcnMgPSBbXQ0KZm9yIHJvb3QsIGRpcnMsIGZpbGVzIGluIG9zLndhbGsocGF0aF9kaXIpOg0KICAgIGZvciBkIGluIGRpcnM6DQogICAgICAgIHN1Yl9kaXJzLmFwcGVuZChvcy5wYXRoLmpvaW4ocm9vdCwgZCkpDQogICAgICAgIHByaW50KG9zLnBhdGguam9pbihyb290LCBkKSk= - Py3 - - - - - *.*.python - 3.* - - - - - - - - - 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -1250,7 +1128,7 @@ false 0 - 155841e4-9095-4931-9b41-7d9131e024c3 + 178951a0-3c74-4810-aef0-87cc45b0502c 1 Double click to edit panel content… @@ -1258,8 +1136,8 @@ - 386 - 175 + 627 + 289 411 166 @@ -1267,8 +1145,8 @@ 0 0 - 386.9042 - 175.51825 + 627.30396 + 289.70813 @@ -1289,22 +1167,21 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel - + A panel for custom notes and text values 5262b483-9441-440a-a74d-8b235aad399d - true Panel false - 0.027397260069847107 - a849584f-8d8a-4547-a1a4-36be0bf3ac37 + 1 + 76758d37-2a1d-412d-b85b-149ecda8a020 1 Double click to edit panel content… @@ -1312,17 +1189,17 @@ - 413 - 19 + 414 + 32 343 - 162 + 118 0 0 0 - 413.26245 - 19.415314 + 414.04675 + 32.380676 @@ -1343,15 +1220,16 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews + true true 6f2c8a4b-d787-4606-9170-900f972641c6 Custom Preview @@ -1374,14 +1252,15 @@ - + Geometry to preview true 43f69636-7c49-4472-9329-bd25ec713d12 Geometry G false - 0 + 178951a0-3c74-4810-aef0-87cc45b0502c + 1 @@ -1461,7 +1340,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -1480,38 +1359,39 @@ - 956 + 953 153 48 44 - 990 + 987 175 - + Geometry to preview true 525f46ad-33c4-44dc-8862-35b0ddce4d1d Geometry G false - 0 + 76758d37-2a1d-412d-b85b-149ecda8a020 + 1 - 958 + 955 155 17 20 - 968 + 965 165 @@ -1519,25 +1399,26 @@ - + The material override 2e7559ef-c4d5-4ffe-a304-c34c078e5af0 Material M false - 0 + fc5dba97-2c1a-4749-9c61-3f88abff00ff + 1 - 958 + 955 175 17 20 - 968 + 965 185 @@ -1578,7 +1459,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1593,7 +1474,7 @@ false 0 - 255;255;255;255 + 255;128;0;255 @@ -1615,7 +1496,7 @@ - + a8b97322-2d53-47cd-905e-b932c3ccd74e Button @@ -1647,7 +1528,7 @@ - + 06953bda-1d37-4d58-9b38-4b3c74e54c8f File Path @@ -1704,7 +1585,7 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -1756,6 +1637,43 @@ + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + fc5dba97-2c1a-4749-9c61-3f88abff00ff + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 856 + 181 + 88 + 20 + + + 856.6275 + 181.76471 + + + + + + + @@ -1763,7 +1681,7 @@ - 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 + iVBORw0KGgoAAAANSUhEUgAAAOEAAACWCAIAAACn9nhUAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAFNKSURBVHhe7b0HlBxZefjL83k+Ps/2wQTbgLHBGDDgPzZ/Y5KNyZwFDOxiYHfZpNXuKudRnChpcs45T0/o3D09Oeecc85Zo7zLBsx57/F+t25Pb/dII41WGq149D3fqbl167u3qm796gvV1T3vcRZn+T0ov3MWZ3lUy9uMjo3Njo4+VBkZmZmaWtBqdXNzc8vLy0t3LGxfXFwem1obHr+0sLi8sLA8PrU2ObM6Ps1ybW5edEdHGWZxbW3t5s2baWnp9Y29fYOLbZ3jLe1jfYML7Z0T3X2z/UOLLR1jXX2z7V2TbR3jXb3TbZ0TLe2jbGrtQHMU/c6e6a7eGRQ6uqeo9w7Ms8rWgeHl9q4JubWnfw6hF4NTYVg2yV4M0tE9iVpz20hH1yTdWbKJY2CTVG7tGKOvHMQpW4kDo21tg0hn50hHx1Bzc+87lpaWvtbW/k2Nt5Wmpp6OjkG93nj9+vXV1dXFxUWFRocisWPLzNzKyMSl0clLkCphnZpZYzk7v7KBpkO5du1aQUFhTX13/9BS78AClPT0zYpl/1xv/xyMSvLYJFpERdmktMhVe3lbRxlEtlAXomwSqxs6CCzKFltFtsuKrUVUnJjeURwY3bfveFRUelBQfGRkulZbrlaXbFM0mlK9vlKvrzAYKrXaMp2uPDPTxJJVNmk0ZWp1qU5XYTRWbeqYm1tUXt5y4MAhV1fX9fVLqytW2mzMwSIITk6vQufwxKWpmVUa2SQtKIDOL2xpf69cuWIymesaewdHVkbGLw2NrcLEwMgyQ2HD2romOP/+4aWB4aW+ocXewQVgUmSR1Y36ljI0umrfi3EY07bVJigMj68Nj63Zje+UexMHRl966bCbm99LLx3av/9EWpoOyOx52kqgMCenMD4+JyAg1tMzCBx9fSMZR6WyRESkoKBS5bOMiEg9c+aiRiP0bX1htKioISYm7t+/9jV3d89r11+DSOzl1OzqxPTa2OSaRJPK9OwK/h0cV5aXqLMVTGfn7xQgwKjRaGpqGxqfuVpY2lTfPDg9f6Ozd7qwpHFkQkADPf3Diz0Dc4NjK5Nz16fmboxNXUZoH5++ivLU3PXJ2Wu0Uxmdukx9Yvba6OQ6q01tI+BOnSMcn74yMLIEphMzV6mzZBB6Tcxco0td00BVXTcD0oI+4zAyq2jKFkZwyh3EgdFTp7zOnvX284tyd/ePi1Ntk1GTqcbV1Qesz53zPXLkzLlzPkePnjt06DSjubh4urh4+PpGxMZmHT169pVXjiiA2jNaqNeXtbS0NTU1/NuX/n1u+dfymgElCGI1Z+dWiDvh0J7Fiak1GCUGvQOgFMloS/tI/8iS1lAWEBwDjmmZBupjU+uDo0uYUjdPP5fTnob8KpgrqWjpHZwvKmuqrOkE5eLy5uq67vrmgbLKtoqazuHx1aa2YQTyYC4mLpPucDY5e726vsfHPyI9y0DoSSPhZlffTHlVO3cF9eMubmp9KSdV19jPEpQLShrQ5CZhHKy7E9M7iwOjiYm5kZFpGRnG1FQdVhCG8vKK7yo4cWzks8++7Orqe/FiKIB6e4fv2XP0+HE3DCqwnjzpdeKEB9wjRAL2fTHAFktNamr6Y489dvToses3XsNYyphUcilEWZWFVagVRnRa8fLW5tsXyWhjy+DM4qutXePAV9fYd/T4OY2hFBOIBUXKqzsyVEawi4nPDI9Mxn0XljYCZUl587Hj59w9/QJDYuHP60JQUqr65GkvH78IVa4lV1MYG5/V0TMFo0hr53hKujYrx6zKyS8qbcpRF5JCuXn4VVR31NT3hkYkYZi5DV565ZDeVGGyVDMCy6CQuENHTnPDzCzc3HRVnGIvDozKUBI0sXYAhCPejqCMmfTwCEhKUgcGxkE5xjguLjssLBlqUcAwEwPAPchmZZkV82ntm51dWFra/PLLe3fv3g1Va6si3LxDgUrC0InpVZZ3BpQiGW3rHMNoQUxaph4zCYsJybndIhJdxBGbC2owpWPTV2gHVoCDsPCoFLWuJC4xOy5R5e0XBnzxSTlRselBofF52uKC4vocTWFIWEJNQy8jYEdLK1pTM7SZ2SbghsiQ8ATovOgbhjXFxEJ5e/ckez952jMyOg0jyo6INxJT8sIjUzCu3CGbropT7MWBURs69yTYQrIio7EaWLGpJFvUJe4kSbCu5FIiWyKv2oQ+jOr15Tk5eTduXF9bW7ttXm9f2I4RRWZmRXZ152KLRzFjoIDXJgrEw+KOCRl7BuY5f+q1jX3wihOnMjS60tAyWNvQ19w+Kh4w9U4TA6ADZJjY7v5ZcAcptrZ0jNFLxJeT631DC/RFgTC0sXUI+9rRPQWd4uHUwFxlbRfjELC2iBhgloOpbeilL3tvaB60BbVO2UocGIW2hywqVaHBUJ6ZqVoQUeddoGMz/l0yOnfHbEkWGDUIXz8grN3cddIdTlh455mrYAGjxIJQyyZWZX6zUbkOxEoCdJVGUSENUty6tHlyK0TKSaSCGkvZXQYA5FW0ILYKOrSjI3YklEULFTmIU7YSB0bz8mQeI0zjwxGVqoCcKSNje4yKYNTKKGGrtXXrojBqrG/uhw/QYckJQ4zgbHwNozg4uoJVs8rY6ttL+8qtomwam7piq99B5G0A0FTuquyU24oDo8nJGuLI9HSjwVCpOOKCTUg9cIFRnQ5Gs7bJ6LTyTIp41Np0xyJ9PT63f3g5v7CuoWkA963Rl5LW9A7M46zlZzxyOTC8hNsVD+SGFlntG1wcHFkRjcNLgyPLLMWz1WFRYSstxAOdPdM9/fM9/eJTq+6+GcZRHpEuygelIi0bEn2r63qKy5ppZED0GYd7QzyFFQ9ZV6yP8Z2yhTA/Dozu3+/i4xMZFZVOYk4CJDHdUcnKsmi1penp98aoSJjubkatjBL8tXdNpqRpyKMtRfURUSk+vuHw1Nk9Xd80QB5zwsUtO9fS2DxI6tPaMW621BSVNBI7lpS3VNV219b3kglV1nT1Diyg39gyBFhlFW1hkcn1Tf2QB7gVVR0k/gnJOVKBJd3Lq9qr67qJg0+cdE9N1zLX1bXdfQMLBKmWwjp0iFnpCKmbropTbCJvYAdGT506D6Z79hzbvfuQSmUhoWH5QAQcFau5uT0zMz8vjzsh7/r16ysrK1a4tihwOSWSevHcdPuMVtV2jYxfau0Yy9MUwxNkZOcVYNJaO8dpzC+oTU5VMxdhEclBIfGt7WNaQ1lhcQOkHj5y2tXd188/0sMrwN3TPyVNe+jwqbOuF1W5+TAH6+CoMLqETSVhT8/Uo2Oy1KRnGqDT5ZSHpagOCxoQGM1NYjRXPf/CHo2u1GCqSEpRq7Ul3r5hL+85zO1B4GF/YZxiE+Y2OzffgdFjx9wOHjy1b98JD48AsvKsrPxtCrTl5AijK1ep0CK5lMvMTHNamp5GWxcpGRlmk6nqyJHjiYkJ165du7MpZZvy4GkNa7p9RrF2NfW9x064RsWkwSjwYU2HRlfx9ZCapy3GjjIXWNmYuEwqWFxf/wg4CwmNDw6NP+vqnZCYTd0/MMrDyz8+MVutK0nN0Hn7hMEfrhzBLkbFpMclZJvyq339I+nOLtw8/Jpah9HxC4gkf4+Nzzp46GRgSKxWX5aYnAupIWEJYErgwQibro1TEDwM0VRAYIwDo5GR6bj4hITcpCTNrTxtLWYojI7OSE2FQjA1p6SIjwCSk7VEtwzFmGFhKS4unuRkm/rCqNFY6eV18XOf+2xERMTNmzetfG1RJqfvmdGa+p6O7mnsZUFRPfYSk4ajpwKjTERlTae5oLatcwKYzAU1TEphSaPJUo3fZxOOnnYqOP2m1hHChtKKNqJMGpXAQLxIhTS3jRjzq5tbR3oH5gqKG1DmrmA04fqbh7CseHwRPJQ1U2EXoEyXrt5plNm19GhO2SRMbEf3ZGBgrAOj0rlLK4jlQ7IyzRp1vlYjJCc7XzZuEsjz8Ajcu/fY4cNnWc3NLWYVY3zsmOuuXft37z6ofObkfuKEB5r2HZH0dBNM19U1VldX/8d//Ace38rXFkUwOrU6vY2HoxQYNSi+HvOJ4VRSFhniiMRFvveE4WQTq2wl0ERBqazK9KhfJEzWzEm6dWnzpPmkF7grxIvshzRIdpfK4qUThWClYs2QaKeXkiqJV6vkrhmBjk7ZJFZGgxwZ3QSQKsucnGJ66WjerkO5uw/lRETp8/IsmVkKqRkmm5paXXrw4MkLF8KOHDmbnm4wGKq9vIJ/8pNfnjzpCawsL14Me/bZV1xcbs+o8qhL/fLLL+3atevVV1+18rVFIaPHjs7M3Suj1peSOHNZ6R2cJx6VBnVDBL63E1v7VgqI2CT5u6OakJ4BcQwIB7Npk1PshSnq7JkKDHZkNCPDZC9ZWab0dONHv5Lxng8kvOcDMd98LDEzTZ+RZsrIxEfbq+XHx+ccPeoaGBgXHJwIrD4+EcHBCZAaFZURGpoUFZV+8WJ4SEgi5tm+I8L4xKO/+tXzP/jBD8bHxy9dumTl63ZlUTC6Nj61eg+MGozKh41X2zrHlfeSrnX2TvcNLYxNXe7un1MeXoqH6nKJDI+vTShP40cm1mQLFflgFZEtNkGZJe1UWAKffJ43PL6qPJEVj0Wlgq07Szah2dEzZRtENtp0Ngb5Qxemon94MTQiyYFRiNkk6lzTCTfN//m3MX/y18Ef+Cvfn37q+Knv7U+KVWXmlKVnFNjUSM/JmUDQ3z8GNIlHZbZEOwSzpJ6VZbHp2yQtzaBS5SckJF+5cply589C2TipPBydvRdGRfY9spSeZYiKzWjtHEtKzcvKMSvnv9TVN0O73lSZnWcZwIkPzAFrfmFdc/voIH55eIkWuKmu68HoDo2t9MqnnsPitVEqk7PX0WGoqbnrbV0TGSojvVjlTmhsHUpOVWv0pSigOTAiogV6KTudvuAdQsg7Pi0e7E8qn361d09SH5lYRxmyJa9/4MJ9y7yFRSY7MKpwJnJzKhKgjHRjbpbuX35Z/H98ufLPvlr6r19LPfy9H4W4vJIV5Z0RH5uWbkHHXpRwthAPvql9KyHNwuOnpKSD1F2fjyof1gtff0+MYkenF16Fjxx1QV3TAFCCjoKg+PydOtkMqXpoRGJYZBKZuNeFILW2GNTCI5OjYzOARpVraWobIQc6dfZ8QHCsX2AU+biPX7jOWAFt6JBmpWXpo+My4IyOsFtZ2xUUEpejLtTqS0USVlBTVdfteSGour67tLLtok8Yx5NfWHvW9SKHpzyu0pO6xcRnunn4oQn0my7YH6DcnlFCxgsXQsnBz53zIStPSzdmZ2iCE0red+K37zn4uw+7/O5ne/WuL3wn4Mh/qNw+pQ3+clqKKjUNTPWbyNu+KIyakpJSsaB3ZXRhcVkyOqd8OeSuRTJKPk5u5C2QKse8JSTn5mgKxSc9Q4s45VxNYVqmHquWkq6F1IKSBq2hTJWTj2GDUWN+FcBlZpugjXp4VGpIWAIYAbqvfySowSjoq3LzlfdTYwlwFS9/rbKmE2udmqHT6AX9Cck5ZVXtoeFJI5Pr4BsTn4WFjopN37PvaHwS0XghgHIPePuGs9O6JuebUEJuz+iJE+5Hj5578cUDSEJCbka6IStd80W3xfe8/Ls/O/S7b5y+efhYrs+5gFhvN1XQt7Qxf5WV+nJyakFqqkDtnQlRQUaGMTFx+4xu94USCozqDcaGlqGegXmdqcJSVI+Rk68e409pZJXs3lxYi1UrrWitqOkkMGjvmjDkVxEGAK54Ajq6gp2zFNWxlb4Qhv3D1JVVthESwGJDy+DQ+CqDF5Y2ko2NTl4mYGAcmCboxFRzb6BWU9/LPcCwmOpcTVFrxxgHBpr1zQOEyFpjGUtCEfZIUMGBbbpgf4AiGd0cjz733J5jx9wIKJ988oWgoARVpjE2yfQlt4UvnF358YWl51z7TnuYg/zTcyPcauK+0Jj+8Tb1Z7LTY5NS8kHtnQnWOj3dkJCQgie/6wN820tPd327WZarV69qtDqIXFh9c3HtrYWVN6bmbswvvz639Gsqg6PibY/ZxdfYOj1/c37lDTaxiiwqLSxpRJMKfdk6v/I6S9G+/DotjCOXKFNZWH2DyqT4esl1OQjLmYVXl9bekjtdWvsNCjQuXfoN7UrLWyypL66+JVs4mKn5G4yAu/8Dl+n5G8wJvsiB0QMHXBIT1TExWeTgipHTJidDkjYzTR0YUbjPo8bTXx0VEdUR9/Praf/7/9X9w2XjN9NTspOSDZuws1Xs67KySWhnR2lpmdeuXd0eo8LXb5PR9fX1xsbGzGwDZgyzZy9YxIKi+tKKlrIq6kKoWMVRk/DRXmztb/eya7SqVShiW3XKOxUuHF7IgdHExDxixJQUPQmTJEywlaxJS1GHxZiCo0wRcTpj4vnVjK+8qf3H3xV/oljlF5tYkJyskQjauiQk5CUlaZQWnV1dm5ZmhEibGsImUrQTJ04XFxfduHFjWVhT8bn8rbKyskQYqthR61dDby8KzTaC19bWmpqazWZLQUGRBbEU5Stizi82mouMZpbFBnOJwSREb7SKTlZoMZUY2WpmKTSpi6VJiNRHU2coFaJ0oREFBs+3FLO7goJCZ7mfwgSWlJQ6MApJykeXt5GUZHVqCixqqpJdhlT/vWj4fq9ud3yiPjFJcAbZ8fG5EkSWISFJrEI8RIaGJsfGik9Eqfv7x0ZEpFGRH7cimO3s7IKDB498+tOfylLlrl++OTu/IgUibSJa5sQ3mMemxBfqZ2ZXpmfFp01SpmZWpUzaVVBWPjhdnVu8urB8fbMsbW6Zd2wRq0tiOb90Q5G3FRaRletLq9eWV6+trl1du3T10vqV9fUrly8LUQp/pDjLAygOjEpu7ijq5CTwUicl5cUn6hITAVQNoBcvhu3adeDIkXMwmp5uOn36IvLSS4ddXMRHTcS4Tz2169Qpr6effvHAgVO0X7gQBqkMCKPQXFpaYbGY/+Pr31pafX1scm100ho1D2+Ez6MTl8ahc9IqiscXQqMiEkcRqioPUK3CJttSEavORnehLB+4CqAVshX0Bf0zc+Ku4PaYn18mtBDfBNx4dCvs9C3G21l2rjgwCjF3lYRETUKiNj5RS0W2ZGSYX3rpkJdXyN69x4llc3KK9u078ZOf/OL8+VAXF4/duw8+/fTuEyc8z5y5ePDgaeUro8cOHTpDRCFGS8hjqdHoL1zw+vFP/3vl0huSQjAF0OFxK6aCyynRKPFlFfIcrOZGXcisEHvUJG1z88sIwG0w9zZ2lNuQJ8UucnCWd6U4MIpFTErCWYvnnRKg7QjOPSAgFuvo6uoXGpqEc9+9+9DZsz6wiBE9fz7k5EkvH59IP79oNzf/06cvnDjhcfy4mwxVMaL4+l/+8ukvfelLHR2dOE3B0Lz4bRLwAjLgw+Dh34FyVGFX0Gm1guIDJ1BbET8MsWUg6yCSReu5O8vvR3Fg9OhR1/DwFE/PIHx0XFy2ZGg7gouHaZZACaz79h0HdFuEILci0rkzLC2yY1xcDi0BASHz8/NXr14VP51ziz2TBbs4NoUdtffdGNdV7CscC1iVjs7y/7/iwCgu+Pnn9/70p0/+938/4+sbZSNp+yLTJljcJt8wisTGJq2trd7h2RNbhENXbCer2FqsLHX7WHNcea90YVEhW3ZzlkesCAN0iw26vVh7iOLAqKdnMDHlU0+9ePjwWdCJj9+uHbUTeomK0t2+/fYiGY2OjleO7PZo0Uw0CYhQiL2UJyCXC8BKPGDNgUQAQP5EMEq4ucVgznK/RUz+nTmzKloLQT/CFRGiJAMyMZB5ArZGBnX2z2cQmWMohmnVgdGYGBXEREamBwUl2ADaUYmNRbKjouKU07sNVjSJV/IUh47VtLbaFTkpnDknZjOrVFhlam43pLOIwsQIsYF1qygKsiicvQ2Z5GxW4WwDMkyDw0NAe8OxsZRia3doVK4dS2u73fMZR0aBRjFvIhOyJ2nnBEa5MbZiVDYoRyzOgVzqFhVrERO6LG5Wbkfxk7kbp830ia1b9Pq9LuKUlVO7i1jVRbE3aYIzgZry+Pl2xsxmxhRoRKAlibET2SIeubBkthVlm5q1caPFJnKTGEGOSS+rbOxaeSYjHssg+EkHRjFpD1liYjCimXFxiZcvr9sDKGefeRRnrhhIJtFu+5YFHawnZ2g/ZfML2+q7Q0Wci71sYmhr2VTwJxIywZmdPROQbXAmURMmTXkAt4kzez7sVmWLQM1mxqyNYlXWbSIVRLs9tfaECZEP/mbtH/yJZ3/Wh80L1gd/yKayaQakODCKSXvHogDnsBodnYVQwV7aKQgubWpKe87Zsx49Pd03blznKnBMFE6DU4UzlsydBPTtyyzF8UzsZWVFvC0t+ipfdGYcpuzOXbYlG7veqgiMNmCS5soGkxUpq5dUrJfyfM0GliLCfohrrIiNMEWszuEWsYLCOYKUI2SK/m04Q2Tj292lyD3aDkAcknJ4AjW7B8zy1CRkNsw2z9WtcrfZ26o8AEYBkfAABIkTbKtwSVAbHp6WmKg5c8aHGFeGEOigYN89OVn71FPPffaznykqLlu9dIM5GlMehTJ31EcnxW83S9+0SeSUbSVSgas7OnGJoeSDVWFv7EwON7q1AiVKUGUvtktlE3kJEXE57UQeqtL+9vW2E8mBoyhPfNmqUGVttA719lZ7XynVJHO2LhuNGyKOZ9Nhi3OxnukGaopJU+yZgppCm5WHDZI24WWTdwTZfRYHRiVbyiNMtaRtOxIXl3vhQtiuXfuPHXOHVECkcuTIuTNnvE+fvrh374lf/OJ5d/dAFI4edduz5xh19mLrHhaWqtOZ0tNSv/2dxxZX35AffiKKYRBXYuPabxbiTkSpW68QXTaJrV1+OsUSWGULHRUmHAa/ZV/iqm+MpigLWyUsltLRqrxh4axdNm11VJOr9goSLCvlUjbwshpXeRdJv0mmIgmzQiY4c7BnlLtwJuXdoO2dFQdGDx8+C20vvnhw/36XiIh0ACJYvKtgKV94Yd+5c767dh0IC0tJStICKPXnn9/3ox/97PRp7wMHTv3sZ7/66U+ffOGF/TQyOCjbuoeGpmi1puTkpO9+7wdLa2/AkBQFI+vVvaPYX/ItRfl8VX67TXzWKrBQ2u3JsMotjW/bJEWsVtZmnxSSJEZWmDastc2cS6QEVTIAsDlKe7KUsi28kA3NP4TiwOj+/Sd/9auXsHx79x53dfXD2tlIuoMQUHp4BMr3o4OCEgMD48+d83vuub2MhuHcvfsQA546deHZZ/d4e0dyG7z00mGZKknBZv/8509/7nOfKy+vuHzlGlbBKjY7sU0R136j7y0CDejYHCsgWidgG8UGhJBNrGxTNro7yzsoDoxi8yAJg4dHBjXsaGRkxl0Fiwtz0u6ePHkeqxkQEEddCTdFu8JxNrGplOholX338PD0U6dcBwb6lR+AUD4LfUdy1wIrFOyizQDbGp3lUS4OjEKSi4vXvn0uipfPAq/ti4RVoinhs7XLuqzYVm0SFJQUERF75crlh/PREDvBXxNIACtL7KsT00e8ODAKMWQwmDowspm9nRYYDQoKB5SHwyiF/czMic/3hU1VPrtyYvooFwdGCQ1JgBAqD0U0MTE5Fy9GBQWFra/f6RdKHnixYiqsqUjSRYvc4CyPXnFg9Omndz311AtPPvkClYcgv/jFs7t37z9/3q+1tW19fd16RA+rCExnV+TTg/F7SaGc5SEXB0Y/9KG//uhH/+bv/u5vP/zhD/3N33wE+chHPqzUxdKxYt30kY8gH6ZdWYou25QPf1jsS6/XXb4Mn+t3/Y8iO1HexnRGZPpOj/9oFgdGP/vZz/7whz984okn/uEf/uFTn/oUy8997nP/9E//9Pd///f/SylU/vmf/xk1KijI+ic/+clPfOIT//iP/0hl++Xv/u7vvvKVr0xMTFy+fNl6LO9GgctpqzXd7s9DO8tDLg6MvvLKK88///y5c+cee+wxKPzYxz72ne9859SpU7/85S+PHj26e/fuXbt2HTly5MCBAwAKysePH6cLjd///vfR+du//VsrgNsoktHh4eE7/1beQyhwKR9IQerM9t5ccZaHWRwY/fa3v/2DH/xAr9d/97vf/dCHPvTRj370xRdfDAwMdHFxeeaZZx5//PHz58//7Gc/27NnDxCz/MUvfvHSSy+B9cWLF7/+9a+DnRXAbZRHh1FZ5IN9MJ3b3g/1OMtDKw6MYin/67/+C0wB8Vvf+tY3v/nNp59++ldKgc4f/ehHsvLjH//4q1/9KuC6u7sTG1C/cOECRpfYwArgNgqMfvGLXxwcHHwUGIVJwmEAlQ9NF5wPTR+l4sDo+973vve///3vfe97//Iv//I///M/v/GNb3zwgx/80z/9U6LSf/u3f/vjP/7jL3zhC5///Of/TClf/vKXaf+TP/kT4oF//dd/pe9f30thBPheWFhYvdv/CH04BSiVD0uFNcWmWlud5REoDox62pWzSqHi5eWFvXRzc6PCUlYorq6utkZCWCqy43aKh4cH9rilpeXdTZg2FTCdnbM+jXLmT49OcWD05hblhlLsK1s1brOg/9prr931h5sffgFL6JSB6awzMH00igOj1rY/+DJh/2m+tc1Z3rXiZHRzsQ9MIdVpSt/14mT0NgUuZ+aU35F0PjF9BIqT0dsXuLQ9MV3Yxv8hd5adK05Gb1+gcmFReWKqPIpyQvouFiejWxarx1e+cDfr9PjvXnEyeqdi7/GVn/RzlnehOBm9U1E8vjPHf5eLk9G7FLicniXHF6bU+brJu1KcjG6r2JIn67qzPMTiZPTuBduJBQVTGJ3Z3r/Od5YHWJyMbqvAJfHopPIetDN5esjFyei2ipI8CY/vfCXq4Rcno9stcDk9a/1NsvkFZ/L08IqT0XsrSvIkAlMnow+tOBm9hwKXsxvvmsxu73/oO8v9Fyej91bAUnzytPEjPM7yEIqT0Xsr2E6CUZk8TTufQz2U4mT0ngtcCjtqfVHfCemOFyej91yg0vbanvM51EMoTkbfSYFL8RxKeaTvfA6108XJ6DssixuP9J3PoXa6OBl9hwUuxXMo+Qa08znUThYno/dVlOdQAlPrurPsQHEy+s4LtnPjOZTyf/ScpnRnipPR+ypw6XwfaqeLk9H7KlApv0yCKXU+h9qh4mT0fgtcTokvkzifQ+1UcTL6AIp8DqV8mcRpSh98cTL6AApcWn97Z3ptzvkc6kEXJ6MPrACo83t5O1GcjD6Ygu3Egv7ePYdaXV0V/3no0S5ORh9YgUvlOZT1fahHn9JLly6Njo40NTU2Nzc9yuJk9IEVoLS9DwWsjzikANrV1ZWTk2fOLzHlF9uLOb9YbyzY1PguipNRa1leXr58+fKVKyysxa663XL1yuXl1WvzS9fnFq+vrl21H+0dFwbB31mP8sEVxjQajVU1LVV1PZU1XfZSVdtdVNpYUd25qf3dEiejosinmhUVFSaTKX+jmM1C3kHR6gt1hgLEun5/xWg0NTTUP/D/voId5exKKxoLS5uKy5rtpaS8xWSpLrql/d0SJ6OiYFSKi4tLy2u7+yY6e0YVGWtpH2jrHKKy0bJd6dqQTe3vTHr6J/MtpfX19Q/WmtoYLbqFCSejj2LBjGo0uomZ9bHpa2PTV8amr07MXOsfXhoaW6PC6vj01cnZ61NzN1idWXh1fvkNuTqz8NrE7HXRuPgaOrLv2NSV6fmbQlnRmZq/qfR6TXZnSV9keuFV27BShxY60l0MsiFTczfB1GQ0XrlyxXq4D6JYGS13Mvp7UmBUp9OPjC+PTKyPTFxCRifXewfnwXR6/sbs4msA1N492dI+OjiynJlt9vYNq28eLK9qT8vU9wzMDY2tqnItQ6Mr9KLvxMzVhpbB7DxLRU1nRHRqUqp6QPQyFZY0MI7WUFpS0drRMxUcGo9aRXVHSFgC3fuGFhitqKyJ7vIYpMBxR9cITn8HGDXD6CYgECejj2KBUa3OcAujC1RALTElT2+qAM3A4FhLUX2GyuTm6Vfb2A+dvgGR1XXdOeoC/6AYVqfmhIEcHF1G05BfBXbNbSMZ2ab6poGwiOTUDF2erqSguF5nqsgvqvPwCoADdKpqu7KyzaCZpy2OicucnL0mj0HKTjIq7OgmIBAno49iEYxqb7WjCwCXkJzzne8+Zimqyy+sS07XcuWksx6butzaMRoakVha0ZqhMp4+ex5D29o53tA8MDy+evT4OWhrah3G9ML3zMLNuMTss27eUKjRl7Ksbeyra+qPik1nqIKSBkwye9QYSsOjksenr4wo9tjGaPuOMVpcWl9Q3FDoKEUljQZzRUFR/ab2d0ucjIqi2NHNjGLhBkdXklLz0rMMCB4fMykAUrZSMeZXxSWq8NoTs9eS0zQ4dFNBTXZewcLKr8urO3DxfUOLTW3DbV0Tw+NrOerCxpahyZlrAFpY2sgNEB2boTWWgy8hAX1Ri4nPAuiH5utNZnNdY09T6wj3UmPrMMsO5TajgmlnySGx2toxzpFLBdyCTVlUWoaa20eb2kZsLbeK3MQNLCuNLcPot3dNtHSM0d2mpmxidaSrd4ad2m9yMirKbRklHh0YEfHowuqb0InhhCeFzqs0ojO39OultbeAlVRpfvl1Wkin0KGysPKG3DSz+Cpw04IHBz66ywqjiVRp7gb4oka7rQVle9k5Ro1GU+/AzMSMODWOATEX1sIEZ9c/tEQsTswNlOC1uPrm7BJBuUglOSM0OXdEhiWcAufIKc8tvUajUhGbWEqfw+yVVrayF7kjluyFYZkuckR2JyZ55Q2W4zNXufOr63rk+ChPzd9wMirK1owuM8XV9T1csO7+WaK00anLuO/CkkamD2OJo0ST6S6rbMOaNjQPdvZMo6w1lBnzq4lQMZmEByRVqMmR71V2lNHuvsmxKeEZQIrA2mipzsox4z0Ghpc4zciYNJ2xnCiF+ITwmtPx8Y+gPji2QrtaV0xLSrq2rXOCEJakkPkxmKsYwZRfzXTlaoqq63txJjmawuCwBDkDs4uvEr67e/oT6Nc19lXWdtXU97KkO/YVR7Rn39HGVmG2DeZKJhkdJ6OiyHh0+BZGqeB3yOKhEG9O8kT0ybWJjs/AW3ldDA6PTMbWcsFw5cSXZOUElzCKMYiKSSPoPH7S7cy5C/fJ6A7FowqjU5JRbBhGtKyqPT3T0DMwT5zTOzDPecFNnrYoLimb0y+vbic6L6loGZ64FBmdStCCZRUn3tjHPenjF+7rH0kSecE7hBmjcvK0Z0x8JoCaLDV+AVGYWyaBLjUNvcROQEmoQ0dVroVbPSQsgVkqq2hLSMoZnVonUgdWc0FtVm6+k1FRtmB0gfs4M1vkQ1W13ZgKrwtBEVGpenMF897QMgi4RJ9cSDJ9bK3eXMnVxanh+JhuLiFOjWi1q29WjvnO5OEwyqHCZUJKrtFShU3FQDIDqtx8TCnuAoygihRbaywLj0rhvg0JT8SgYm6DQ+MTknMxmSgTgl/0CcWOQhj16LgMckEcd3KaOigkDsvKvhgckxwbn2UuqJFTSndug+DQuKHRFWwnppogPj4x283Tn7mlxcmoKFZGxzbbUbzeyMQafgpXjgNiNuGSiRMOrmvCUlwPsphPppuW7r7ZrJx8Mv3Rycv1TQPF5c1EYwRYgC7HfGeyw4xafT0Cpoqpu4z09M/RQoWbDQXmAWErjdIn4CtwIMNjq7KibF1lq1RDOOuhMdGLGRgcXaaL7C6FXrQTOMnRUOgfXqSOPhWGsulzVE5GRdmKUeJR5qi7f47pxqwiBJ1MJaYRn8UqXBKwMpt4Rq4KBLd2jMl5p6McBxGVKa69qNBubRGbhI5ji/UAbLKjjHb1TTK+2KndAeBqe/vnOSnrqnIu8iBvbbFWRF2IrdG2ZGSxSdY5o43uLN+u2I1/a8XJqCh3ZhT4WJKEynSVTbRwCUlXuenR4e5nKdUwD3Tv7J3GFGGBFDPDpqt4OrqwFTcqKkoujxpLNoH72JS4KnLv9rKjjHb2jA+PC+OHcGtxwCwRDowWjlOKVJA6eGTbqrVFsX93EBRsxliuimFv14vBufmZE/tGJ6OiwKhGMLp0K6PMJqvMVFlVG+k8Lp6A7OU9hytqOgnL4pOyWzrGcjWFAcGxrIIgU0wlKCT2gk8oyqQUbAVBIjCyAa492QZh39jkpVxtERlDVW3XsROuZZWtS5feIKTTmyqmladXNoHRts7hHWK0tX24d2CB2wnp7JkuKWvp6J7sG1wgqe/onmpuG0FI24fH1qAHXzHIDTmygjIVWtCksat3ZmB4WTA3soLICu1Do6v9Q4uMz7K0vFXuBc/DqhyWcFY85BpaRETYoFQshfVEsfJOkMpORkV5m9ENV6swKnImMlkS3thEFWgS4MMcmXtKmgbj5x8UHZeYDcckxRp9CVkUhhZzS2BAR4J9NMn0yWrrGvsZkLQD4klNyDa4DGfOXSTTggmoJbQF1nPuPjnqghnleapNBKMdO8nooGAUpPqHFuISVJXVHQDX3jVJrhMQFJORaYiOSc8vrLUU1nGoYRFJBlMFNJOJm/Kr2zrHM7KMBN/lVR16YwX3cGFxA/E6y+7eGUtRXUPzIJxxvgGB0ZLRkfE1VU6+h1cAc1jf1F9V08WOSEm5XRnHbKl5Zc9hxuEmIaPiSGrqe52MiiIZHdrM6DzL5vbRoNB4YCIHYh7Lq9uhkMx9dvFV34BIktCSipa4RFVsQhYurLC0CZ2FldfrmwdI87nSqRlasK6u6/YPjFbrSzGxPn7hQF9Z23nG9WJymoYWrjcpV0v7iI9fREh4wpzycYBNpB017wyjLe1DklFkdGLdlF9VXdsNGUTVHA9H3tA0kJ6pB1ZyQfJ6/8AovbEc88npJCRl0yslXVNT35OVbXJ19/H0CvA6H+Ry0sPN3Zd8//CR06HhSdl5Fjj2C4js6Z9Hn8FLK1qZruRUdXZufp6mOENl1BrKPc8HNrUOG/OrmG0CpJCwhJdePlRQVJ+UkudkVJQt7KjIGzBveO3xqctwKT84kd5/bPoKCvhr8ifS+dQMHauk/yZLNfh29Ezh1mcWbhaWNpZXd3T1zSSlqtW6EnxccpparS8hJABuYSpGlrCv7GVh5de1jX3cCWySxyBlR329jVGww0yevxAEOnhqGMX+wUd4RJLRXMUR0o5nyNMURcdm1DX2QW2ethidoJA4wpjMbBMKEVGp7p7+yakaAA0IjgkMjsXWIqnpWg9P/5a2UfaCf89VBslUGY351RhUbDOWFWW2MkW+fhG19b0wevyEW1qmnvvEyagoglGNbmj0VkYvYRdxXnAjPgZcuElaA6biQ9Gpy7SsXv4ty5X1/1m78n+TTsmPQOkrgaayfOk3i2tv0mt++XUaiQHmV6i8yi7EO6bzN9BRUrHrxHyMTKO8B2wifb3ZvDOMtlkZxdcTgFbWdMJf3+A8rpaW9q4J/C9bWeK1iSBpIW4hAK2s6apt6FO6iA+K2IoVbG4bpc59SB2dhibxUSoBJZpNrSNECIyJECGwIyrosIl90b2iqoPR6EiFvaBDI7cNvZyMirKVr8d9c3PjuGGIaSWnwXJgBrCabV3jbOW+Z1qz1QWZKlNdUz/2hvu+qW0Y35eVY8aaqnIt2XkFRKgMKEe+V7EyugN21GA0NQtGhQvmvBRHLDIYKnADQGDE6bPKEpGEyRabpqxIBYQcSFbQlO3o2CrsBZGbWLVtQhiHVVmRe2GT3KOTUVEUO6q/1Y5CYXv3pCrPgv0juCRqVOuKsQ04buJ9Ii1g7RmYx3jQQphF3JmYkgesxK/xSTn1zYPn3H3PXwzGNN4Po607Y0cNRmNL+zBMAATWlCXJtVzFjAlQ7OC7TyF+cGjZemTmfHBkWWIqxcmoKFsxKp/PaY3lOGtCtBxNIek87hjTCLUnT3uFhCfWNPQqLYJjLjCbWKUv5hbvT/dNvvteZQcZNZg6e62fM3G+MviGHvaISWMVgRg2TWy8tDU9f0M+IVaCH/H2FmetHOQVYh46yqBIfIakvOGFAhWWuG8q8owYjZFlX5vQiyOhOyagpWOMVeooo+ZkVJQt4tGFkYn1sqp20u3G1mEsJakA8RM+qLi8hexeZPQJKiKBnoE5jChBKmoVNZ3EnTRyvYkQmGJEjvkOhOs0t/R6R/eY2WzeAUaNnT0TklERUXROkKNEx2VQJ7Nubh+lTlKYnmXErMINvBK6VNV1E7qItz9bhwZGls0FtYSMHT3TnDs+h0EIdaiAHTrcolToEhOfJc+ImLuwpDEiKoWRuZMJh/D+5JeMxjSieeKkO3NORxJNJpCr4GRUlK1yJq4BF0Z+Hk0jVw4DwKRjKVEASsV4iM+cFBDZJF4tZRVTMTV3nS6Tc9elPcCosFVsUrqgTDu95IA0ooMCS5vQ3tIxWlTaXFXTZrEU7CijHAYHDF6GfPFGHK6WeJR8EYYys82hEUnxSdmkU77+EeaCGvLF8MhkohomhxC8rWsCp+Hu6UcuHxQa7+rh6x8UTRR06sz5mIQsS1E9TobbW37wy/xIRgnl9ebKguJ6vakiv7DOxz9CvAJRVB8QFM34mdkml1Me5GqoORkVZXl5GUYHR5ds/miD0SXogUguG5Mrnz0xlZhJNrV2jhN3Sm8okcJ+yASrtpFMdpgWQtXGliFYrKztwt8xCOkqHWWFWBYyOnumCBgYB8MDK6NWQK+yI9+AKCLasMh4i8Vy9epV6+E+iLKJUfEackXrWVfxbZaJ6aswyvEkp2niErNNFvHlAkwsAKn1JTRymqHhiSZLNecVGZ0GjpBEsB4eleLu5Q+7wOrtF+4bEGnIr0LII70uBHGy6HNnFpQ0oEMvbDBqMXGZ3AzcBmyiJTgsgRsjMCT2wCEXSCUfdWB07ZEp6+vrq6uri4uL1hnd4QKj6tsxynXieoAXs1ZQ3MB8NbQMBYfFP/fCKzX1PSRDIWEJUDU2JV59QBmPlqEyghq2gbkmMMAYcAFwjqrcfIJXukfFpGE/gJgLz6XtG1pITtVgWhiHy4zfHFMiPG6G4rJmLvlF37DAkCijyXTt2g4yyk45R/aIt6WFeBSeuEk4d5wJJ8IB45G5u3DE3J9EO9yfOBa6EN6Ih1Pi+yRDJRWtLOsa+zt7Z+SnaAxeXt3BCPRilhhWcQ5Ng6PLzDDdCRLIMgvFe7fiqzWW4nqC/pb20fKq9s7eKTy+A6N6veHREL3BYBgZGQFW64zucNmC0QUmNL+w9riLGxOHU8Mf6YzlXKdK5RtILDEGlbWdOH3sEIxmqAzn3H0wPHh2NLEcxWVNyveb57keeMm2rvGUNI2ru09EdCpMAHRWTv7xE65cKiwrl5/gzMYoF9LjfCCMBoVEm0zG69evWQ/3QZRNjCJU8Bg4Ac5d5kzYchlSczpKrEJyc5UzRYGjpcVaEfEMKY4QVlnSS2rSBR0U5LByR9IpMSwi9ZWOInzClFKhXQ6l7PGKA6PT03OPgszMLAwPj2u1uvn5efkrNztdtvD1C0xZRpbxrJs3loBsgDQIG8mMTynTB1hxiSrcdFVtd1Jq3vzy63BJntHQMghYwid2TRrMVVTky7x4Li48rCOEBKkZevSxIoHBMcDa0TMZFBJnNFcRy3IAklF3rwCF0SiN1rx++Tpz8aDmQzLa0T1OmMhRSQEOOQPcKtxycipsW7cvjEPAbVulbr9qL5LUTY2bxIHRqanFyckFKdTtVx+mTEwsLC2t6/VGTOnKyop1UneyCDuq1g2OLDoyiq9fI5qEldaOcWEsBZrWtIaZhdfqum44xh/h6dhU3zzYN7TItOKnwJpMC4Kxu7i5kooWlLnwOE2W2BgcIpksZoMMGq+KDjuiUbnAIsciR/E4H+Dm6R8QFKHVWxaWb05Or87Niwm5f1Ilo01tg7ZH5Yjw0T1TtMjPmQZHlnEXrEqhRS77Bhfw8rZ22ybaZYXuWGLqLAeGl4SMLNs/E5WP+mlHkzjBNggiH9AKHeVhPuLAaFfXUF/feF/fWH//eG/vaE/PKBW52t8/oSzlqqhT2SFh16Ojs1qtfmxs9OExert4lGmaEb+c8zqrGE7okUspOCObY4I5Khg/6eDIrqaVD06pzC6+RndlKQwGOnIv2EsUaIFyutDIaNKIKiJiXCKNpFS1wVSqNxUvLN+YVH7OHJmds5L6jmG1Mto6CA2Q1De4SJIXG58VFZsOJR3dU9xRF31CPbz8zZYaomQyvK7eWYJyAnGiTFZb2sea20a4h1s7xhTaxrp6ZwZHVhqbB3Evza0jksLKmi5C8NR0HWrc6m2dQhqbh1rbxXeXXd19yajQJKFEGfvNfju6JqmAL+B29885MKpSmS2WGoulFgkLS0hMzC4srDebq8zmaq22xGis0OlK2cQSKSiok5seuJhMVaWlTZmZOePj4w+VUSWot2cUg8eSgJJ7ncwgMUV8V4QQMyVdQ4BPfJkhXrdbJRtFh+zHmF9FBZuRnWfRGsuIFghhSVHRIUUgbcKWcCXAdAPEOwnHgDUF3I7uMZPJvLp2Tf57UvEzvAqpUzNvm9V7hXVdMtoCo9aPJcGrqKQxKDiWIyRKAaC0DF10bAZmPiIyJTg0HlJJ70j/TfnVLic9fP0iLniHnD57gWVOXqGbhy9BC0AT2wSFxss3SLDEZRVtxDDJqepcdSHzo8rJL6tsIyIvLG4sKK538/DjfiCtPHLsDHsniUxIylG+3hR/8rQntwS+yIFRX98ona4iLc1w4oTHyy8fPnnSKzIyHWH1pZcO799/4siRs+7uAXv3Hjt06HRMTJZaXZqdXfjARaUqMBgqUlMzJybeXUZFPJqVYw6LTB4ev6TRl8bEZeLENfqSxJQ8rE58UjbRJ+1qXTHxKPd9e/dEUGgc+SwpUXxSDslTbHxmdHwmFpfMHaPIyHpzRWllG+bTtq87C0a6pX3IbDZfvSqejwKl/KloxaAKZG2wLij/xEzyeldir1y+bM632BjFYnEfJibnhoYn9vTPYvOGx1Y5d7+ASI4hJCw+T1MELpwUZ60zlEVGp4ZHJZ9z846Jz/L2Dff1jzh/MZjYPSevIEv8HlZ4FWnl8BLcFxQ1cG8zUWptsV9AFLwS0gQERWMpi0qaAoNjMcARymvjYRFJmSoTuOuUV/WCQ+KYbQZxYNTNza+4uCU8POXECfeLF8MOHDgJkR4eAbt27Wfp4RHo7R323HOvnDlz4dw5nwsXQvX6ytzcogcuOTmFBkPlw2b0NvHoAgEogOLvyOvJb5JS1ESZWbn56SpjS/toUWnjsROuenMltiEzx4z7I9b0D4xqahvRGEqPn3QjGCVOAFDsKNYF+4pPJzCNjEnFoOLo5b7uLIS5zW2CUfkMXyI4v7Bs++fkkCrNqqQWXmfmVlCQD+6syNrJ0tLi+volRktOTmluHZKMEvZhJvWmClwtEQ5nRwv3FWeNTdUby/OVz5MM5kqEFJB8EXOoN1ZgVrF/BLJUcOvYzvzCOqwpI1AH/Zr6XqwjtzSOXqMrFc+qqjuwqbTUNvThcMSDrYY+Y351ZXUn94ZUxorLPW6ORwMCYiIiUqOjM8+cuXjq1PnIyDQqgOvrG0k9KiojLk51/Ljbk0++4O7un5lpzs0thqcHLtnZBXp9RUpKxm0ZhSdr7V7KnXttwah4f5S0Bvfd2DpEtp6WaeD6lVW147XZVFjaCHCk+VRyNUVDYyvYVJS5MObCWuYdM8xQGEIuoaWonpBUhgoMvk1AERiVdtT+cyZORp4QLAKloNPRsm6IQBaaZ2ZXCGGxtSI2WL40Mzv/wx/+8Lvf/V7fwKzN10PD0Kh4p6RXee8JO4enxprSLr/+gQ4Kis6ySKeG2bpGhU3kQCzpiw4VdACUOoMwG6ixpEXqM4cj42uS4JHxSxwA3dlEd0VH9GUTg7BrBnFgNCVF6+kZiB3F4+PH1eoSjYalqOTlFUOkVlsOwYGBsSZTNQYPmBBjWok5dSsp1WYWqXKE2vZFpbLodOXJyen2jC4uLq6trRHpK8bAoaCz6lisGxzKkvLhwO0fuLJZrdbeyiizCWfKr8eItIYEaGzqCgn+wsobtMtUCeXJ2esYS7oQaKIMf7QQSsqhEICWUKIjHyvaNt1VFDs6aNri83obrDj62fmVqVnxTyOgU7GsVKRYeZWVS1feOn3W66mnnqytrVd8vYDJXiBDMrqp/X5E0rYdQXOTsgOj2DCgBEco2UrQgU5Zz84qyMzOP9CY/lxn0gsdybfKs51JF0ry1BkCu+1LVlY+h5GYmDYxMWFjFLwGBwc1Gq1Wq9Pp9DYh8NfrDSpVdk5Obl6eGgXSC7M5HyV7NUStVnd399wWU8nowC2M4p0lcLTAFq6cWLO7fxa3jkUEUNBkk+BY/ODtFTQJDyRYiBzqPuXOjNoX5e4VlcXF5fn5ZQwnFhQ7Kv/rrg3Zy9d+8/KeQ2fPnhkZFV8IGZ1Yx3QJUW4klggZOrvmbhRnpHw8Ids5R9qlMkK7vPfk6laCGrGsqCtfIqUL08WwtnFswrSTjOK7rGMqCg6MAsc9SU6GJS3b/L43vN7zu2Pv+Z3L7eTYjwejjUlFmzreWYgisNyJiak2RmEIOwqCo6OT8zisuSUpXAkkPDzizJmzR48ee+aZZx9//Ikf/OCHdXWNa2tXZ2cX7TVnZhbUas3U1NRt44e82zHKzFIpqWitquvmgilvi86RtJ49dzEhOae5fYToCkBBlgCrtXMctaKyJmYZz04sJa/ffYqVUdO9vfckebVRSyE8XRCyjCFt7+j6/Of/15NPPT2sfD1Q7mh26bVcbRHhIBUcCKGh+H6LvpSkW7qL0anL3KIYObiRNNNIGMNNyyoTxVJUlCVdaOHGhnIUCMfFCOKTpGv1zYPMJLEvu5aDsGTTyMRaZ++014UgU0ENHknxVOK1GwdGgeOuIjHKyDBRz07PT802feTmBQXH07cTlyf6YvRJhfYjbCWSToTBMdXJyRlwacfoAvZybm51ZGRmbGwWGR2dnZ+/ZDIVHjhwgOjq0KFDycnJ//Iv//Lnf/5nzz77wtzc2vj4vNTcUF4zGs3T01O3mlL2Ql4/MOzAKE6QJbNJ9Im9rK7ryVEXrl7+bUR0Gmk7BEdEpR445EKWmpltIqniAp85d9HDK6BZJPiT4vlL+yizLAd8xyIZfaDv4S9eu3a1v7/Pw9Ozu39GfvQKTNxpHD8nS9zMuZMqEVuT8SQm5/kFRkXHZpDKnDjlzoQMT1wi/ScN7+ydIcFv6xzPUReQidMSEp7o6u7LuRORnzp7PjlVTeIYE5dJC7SxI251si53T39ST0N+FTiSLRnyK89fDEaT++HMuQu4r1xN0VlXbywCKG+2o+npRslKRoaABs8uG2U79CQna5KS1HhkQVWqKUVlvAujvTG6xAI6ymEZR/Itl0qjgJ52omEaEerY0QsX/AoKLDdu3GBSWZaUFIeFRQBoe/tAR8cg0tMz2tDQcfjwsccff/zzn/98RkYGp7B79+4PfOADH/zgBxMTM0ZGZqWmFPrGxiZoNJqbN2/Ka0XhNiB+ffXVVzUaPfbPnlEoxDFhA5hHTCaAcjFwUqERSUzcyOQ6Uw+ROlMFk87lJOWPS1Rlqwu6+2bMBbU19T0b5sGBuXsVGG1qHbQUFPzmN7/hXrUe9/0VzvrmjRuFRcVtXWOSUe6ljt5pb98wcJxffh1jSQaTrjLmagpJ7TNzzOSLhSUNJIWce8/AfFhkUn5hLbeusLW6Ep2hPDY+KzAkFlKjYtP9AiLPufkAK9MCbSZLtZuHn3yUwemQ12NW6Wi0VEfFpCUk54JpZHQaYVJxaXN8cg6avv6Ru3bv5+bPynH8TbKYmKycnCKyooSEXECJjVW5uvqS6QMTJKWk6M+d8z1/PgSFpCRNfHyOKs2cnGVQGD15C51SYDRaEy8ojIrKSExUS0wBnXuAQdgF+2KoqKj0w4fPZGVZ2JqWZiBnOnvW4xOf+PvExMTf/vZ/cnJyPvGJT5w541Za2oSJVauLEfK2w4dPfVUpTz75pIeHR09Pj16vh9H3ve8vvvzlr+XmFmq1JHxCOS+vqKio0dc38JOf/IewsLCbN29IP7i6urK2trpnzyvPP79rev7tbEYyyg0tPQ6+r6NnSm5lBtnEdJPIcyGlt5K/rkOFWx+yERnF3r+Mz1ztG5r91re+7e3tfe3atQeF6fqlS3q9sb1rXDLKWUwv3MSUcndhU8lUcMSlla2qXAsnzk0Imrj1iurODJURjwxh2DxOFsKy8yzmghrxyKmgJik1T/yYurG8sraLZV1Tf9/QQlaOGUOLsmB05mpZVRvGuF35mdzE5FwINllEx+7+OZySCKLaRgiWsOjc57UNjr/tuG/fiZMnvfbvP3HihPvLLx/Zu/f4k0++4OUVnJ1dCExsffHFA4cOnXZx8fjVr3YHBcXj6xMzdB++cX5rRk/+tCfKkFzk4xPx8suHDx48BaZk7oy5Z8+x48fdn39+765d+194Yd+RI2cRGE1N1aek6LCmWq2porzsX7/45bnFG1/56tctFrPBIIx3crKOuwWO09KM3/rW9//pnz5HOXfu3J49e1JSUkj8P/nJT77//e8H01deOcIthzJCL26znBxtZ2fHF/73F4dGFmbmL5NSXLn2+vnz3t/85jcyMlUjyk9hSTJsjFIhl+fuJ2HHT2E5qCPoMONwqSiIiuxFXVbkOPcv7Ku9ayw+PuFLX/pSdna2dCz3XzYxioDp5Nx1HAV1GB0eFy8V4PeBlUaEUBKFuaXXOEdsLS2cJhV0pudvgjjzM7/yOnXmSvRdeo0bFWUqyiMRa3ZFI72UaRS/LazM6k0qo5Piw2RGUPYoWpRw9poDo25u/k888ZSHR6Crq98TTzwNhRhO7KhWWx4QEHvgwEna4QmqoA13n56kT0jX3pVRY2rJ0aOu7u4BjIANZjQ/v6jvfvdHJ054nDp1gTHZ7y9/+Rx2VLHWuuRkbXo6IakuKyvza//+9dX1X3/7299LTEzIzdVjZbG+KKCGzje+8d2Pf/xjQBkSEuLry6FG4BCfeOKJP/qjP/rYxz7GnQb0KCP0UgKJ3MICy7996ctjkyuTM5fHJi+trP/msR8+rsrK7Ont7+mftbFFRTLKlejqm2nvnuK2DotMlr/1gAJzR6Wta0LqS4srbeqDFa5lbWPv8vKKu7v70aNHX3/9dStl91duZRThrKUojD7Ic7FN7F1FHoB9iwOjZ854x8VlHzp0Bkx9fCLxzr6+UadOnffyCvH3j8HsHTvm5u0dfuFCKO0YvLREXXya5s6M/qQ7Uh1nJorADDOOn1+0p2eQu7s/40NncHBCSEhScHAimCpjGiRPeXnFR4+e+sxnPmM2m996682Kigrs5d69h7CL8fG5CQl5CQlqooX9+0++973vdXNzNRqNf/VXf/XpT3/6rbfeQvnDH/7rH/zgp5hPhlKU8+Lj87DfLi7nPvOZf8zNzb1xQ7znRrlx42Z6esanP/2pi95+49Nvzw6V3sEFrhOxf562eHBkOTVDe/DwycLSxpQM7ZHj56CT4Cw+Kbusqt0vIOrIsbOE/DL/fbCCc+zunzp8+AgzUFVV9aDexl9fF4w2tQ4NDC+TIXGyxDMEmtyQIqnvHCekYRKYAYStrKI2OLoin8aLVdkiXoxS3lSSLTbZ6GKVjTpDKd7psvL03tZu7SIOZmiRYxCrG10cGJWekWuPG0UUn2uOisqEXQDCJtk24Wq5/KkJ2rhU9V0Y7YrMjhbuGxtJd/hmNJBlFaMI6FIwinJMhHiAVW/vQPwyro2M/vr16wMD/Z6e3rjs2NjsuLgcRJL3ta9945lnfrV3796Pf/zjMP3MM8/s27fvO9/5rrt7IOciNZHY2ByOwdPTp7W1mQyJpEFeKkglyEtIiD946OjkjHj5SJJhY9SYX0XUT4UMiQAfNxQUEvf8rj2pmTrSI/KGwpJGDy9/Gom9MK42th6UYJ67+6aefvpXFks+82A78vssktEG4sUB8TkTgXVFVcfps+fJWsCO7LBe/IqOgfuQsBKPASskUpU1XeT78tMjWuhYXdetfOwp3pUBVtrhjDrLjfoyoWeq8vusPX2z9Kpr6Ffl5OuN5SgwgnxiTxcqTa0j/oFRRKiD4ufNxAiM7MAoVx0+7IUWDBteEgu3aROSEq+JTcn7y9e8lLz+1O3E5b96wlVROlsXQGQ0xkxM3Lwvm7BTeIqMjJ+fn7M9eyJVCAwMi4vLjY5WxcRkK6JKTta7uvr/xV+870//9P/66Ef/5iMf+QiV973vvU89tQtAN9SsEh+v9vEJmZmZJpGX18lWoNZoEv/Fy5FRq68nacBqFpc1W4rqYLS8qp0coqltBCFdAGUq+UV18mGqja0HJfj6xub+8vKKN99880EBSrEy2jwgPwsFkeq6ngveoRpdKWS0dYpfKIlLzC4qaeTmDA5LIG2vqe89ddqLVB398MjkyOjU1vYx8nFyqaxss9eF4IioFOT8haDwqBRyr/MXg9My9KRZcQkq8nTJIuZTvDbu6k3OrjdVGsxVLLkNvH3DKqs7cvIKDh05zd5JyHz9IrhVdIbyzYzekyTFqWOScj+56vvnb7q99w2PW+XP3nL7eWtUZqTV4W5T8OZJSdqwsJipqUkbo5curcXHJ0Gkt3ekt3eEFAIGP7+Yn/3sVwSm3/veD7///f967LGfIGfP+tJuU1Mk0sMjODg4Qo6mXKa3y8rycm6etn8YRq1P3W2MUsE6Kt+jEN+5kwmE8lmo+L8Zl67+P7RQWV7/H3ICfL1Mnoj9yQzoS4sMABhk4+G2+JYFarLCHsk2GIRN7EImFvaCr29svedn+HctmxjFvGEOC4oaQsOTOrqngAPjR/Keqy7E5iWnqkm34QnLqtYWszU4NF6rL8PaKa/SFefkWYLD4uHMzd03MCjG83wQJhkhbSeFxxjTjgGWv/PI3U67+GK0phDQuQdQCAqNYzSzpQZnxQH4+Ia/8OK+1HQdu97MKHzExws3ulG/u4SmZQVlZAWn30aCMrMik7MT4jZ3ubNgLLGmISFRNkYpGL+pqSmNRpuVRXabYy86nUGnM7LUahE9ldxctUrloCM/LN3qO1J3ZrRH+WhOGlTlG2fL8pMVYoDQ8ETxNbTKtjxtEZrYBvwU5GFoTZYaemXl5MvvT1qK6wmzsLhkXVpDaWllW0x8JvYD65ueZWhSvpwen5hNBSjlMUjZOUZ1wte/zWhrx1hsgspgqsTJSvdtNFeBSG1DH6Rm5xWIN0ctNRjFxpYhzGqepqi1YxzUMJZAhtASFZOOJc5U4ZZqmI3K6k7cd0qaNiVNw/jsBYNtzK/mTAkSKms6wyKSctSFGl0JaGI+2SM3SW19r1pbEh2bQRxVVNrkwGhERBoOlCAvMjKdinS7tiX0KHVZ0SgwiVAvKSY3OTov6XZCe0KsVW37QuzIHoODI+0ZlQ/br10jZ3iHhbgTQG/rLq2Mbvb1YrWiugPOZhZuMqfMbIbKlJ1riYxJq1J+NgdTQapEO9cSLgND4tIydJ2901gFyCspb+HCwCLxnCG/qqKmkzyAAVPStZBdVNacoyksKm3EM+aoCwpKGvGA3AN2r+JvMNoiGL364Bk11BOP2r33hCMWv4Vre+9pdIUWLB+NCBVM3eiEyHVop77RRbwVpeisspXKsPKbuiPja0o6Jb48g5r09WJY7vyJSzJ+HZu8rHRf5kxRIHgdnRCf8DFjbEKHTQ6MknSDKZGci4vnwYOnyeujo7OCghKosCRZIbunAsQBAbHR0ZkKT9kPXOLikLygoAh7Rne02DHqYEeHxtaACS7BjhRefIEuVU2wn5SaR1SKu8dHT85dNxfUHHdxU+Xm948sAW6V8vja5ZRHSUWLSXm4jQ0uKK7HJCyuvkn0Bs0rl3+LWQLiwdFl+YoqRrq6vgezJA/AJjvKaF1jH/4XbjbE+qpRc5v4f3N27fcrks7tiDwA+xYHRvfvd4FC0vbDh88+88wrrD7zzMt7957YvfvQz3/+7NNPv/jiiwf37j3OKu3YWhjF3O6EYEoDAsKmp2/z/sdOlC0YFf/TtrCkwT8wGmOJwUtMyc3KzYdLaW5Z4sTJaYDPrLxjT4CFKyT3YrW8uqO5fdQvMEqVZ8Ew4OIJ74hNGaq1c2x6/iYKxAwoi09ZuyY6e6bEW/2GMtCXxyBlRxmFRYwc0YsUTm1kQvwWPREhS04NYybs2YYCyrRTwbwhsgVDKFts7bY6S1ER2eRl2yo2knCcqZM6NpGb2Kk8JJu+A6PPP78PU5qVVXDo0JkDB07C6OOPP+nhEfT440+9/PKRZ599Zd8+FxoxsSDr7h6AR8bQ7oyo/P1D321GrfGoTHpk9sPMIrJF5j1SQaRTYlV+MCPa5Scr0tBSAUq2Mj4KRA5cBlokjqRKchwCWblJHoOUHWW0rWucs2DXCDFGQUlDnk78WyncOvcP4WBFTQf5vvhfjMq/YJQv1KKMZ5Cv1TJLNHIunK9yauIrisonTOK/NnJeDEtHHAvnQkeyT25+4hyCJU4cNYR5UD5VEi8BpmZo5f+4QpSpdvxfjOfPh50963PmjLebW8DBg6fc3PwvXgwPCUny9Awmoca4Pv740+7ugaTMR46cCwyMx+BFRWXujGT5+oa864wOEiqNrhDaj01fwd03tQ0zoaRQleL3xq7VNfWTLaFcUNxgKarnuja0DGEm6ZJfWMv1HpkQb5vj8fHjOH0MJxW9uZIKl02+isqOcPrYUQhmF+3dE1wYeQxSFEYHdohRLLpiO8WXBUjXznuHcLLUORciabIWTiQuUUVST3rOwbt7BRA6KyTpktPUOGI2EQ6RF0ZEp9KIkEcmp2kaW4fIwIhzyAVT0jUE6JwpO4I8/Iabh29Wjpngm2iH+SHTJ3liPvWmin37j3PnsImAitu1sLTRgVE87MWLEWAaGppMekRoGBOTDTFKEqO+cCHcxyeSbAkjR8KEtYuMzNghiYjI8PEJftd9/bDw9Y0ZKmNxWROXEF+POQGyjGxTbUMv2U9gSKylqE5rLA8JS4A5lIND47nMpPlBIXGQR2yACalvHshQGUhd5U+bkPzSkqspytMWd/RMc5m5nBgVsiu1rhhTJI9BysNhFEMIKAcPn+TU+ocXiUC4u9S6korqTpYwh3AvkQgCDTchRDIP3FfZeRZ4gq2Q8EQCm4s+oX4BkSw9zweeOu3FjKly8gHdxy8csplVdlfXNEDsTuCuM5VnqkxpmXpLcX14ZDJBBfc8aHI8DPXCi/s0hlIm34FRBUfyFfGc3M6kCYmMzJRPwqls2rQTEhmZdf6830NmVHmG78AoIVG6ytjYNkykiNORT5GYd+xlrrZoeuGmMb+qq28GP6XWl3DlEKxIW+c4F09vriA7PnrcFU3sAQ5RayxDk4QAu2vMrwb6ePFvSZZKKloJVbnSp86cT8/UY2nkMUh5OIxKI6c1lCHi3JXfDyO3gyTMm3gCqi4orxL/w5fcsa1zIio2HYCYIvmbZPQCZcjj9KmnZeo0+hKA5r5lEqgwgd3KP6zCSBstVYBIZslW7mS2chuHR6VgvM0FtVjcRqZXXUgqSaKJoXVg1N096FEQIuBTpy7GxSWurYlvJlkndSfLFozOj05cKipr4qrUNvbhoD28AkgmIBU319g6HByWwISKzwaVf8nMxcZ84rPwffBHjsUl4drgK7FJGN2Kmk4YZdJJ7SE7KU0DBORVCcm5MMoeWaJ/K6MNLQPGnWBU9zajCAeghIYim+FG4r6iDlIoSKGdFnSosKrMlfj2CKeptAhlOQJLonBaxPEr7zfJr9BIkWOiJtqVDzvkgOxR7oIjYckmZcyrDoyq1dpHQfLy1AaDcXZ29tYPLXeorKws5+behlHsIvWmthEmnbiKW59glKls6RhlNgm5yCcwkLQo83sFOhGmlY7yGvcpgR0XQA7FsNhmKrS0dIzJn5LD7wMxu4AMsnta5DFIYZCG5gGj0SS/X/+gygajb+dMNuHUxINP5WgfBXFg9Pr1a4+IUB6Ol5fFyqh4aO/AKPxxl3PfS7AQ2GITS4QIkgssrQWaLKUZYMnq0NiKXJXKcisVaS2khaCCjCo/TEcFnU0P8JEdtaN4VcJE8ThdudMmsXBTVzjZju5J5XH6pRHl9mMrOuKJuvKv7e1liAhnRL5EsrWMLI9NrttW0Zdf9LO12IRNE8yn3R4RB0ath/+HV7ZilMuDU05J15IhiR/tCIwSb5YU10fGpMkfREjPNHCNY+Oz8Nf0Ij/AXzc0D8bEZYZGiI9JWSVjIAtJzdSRDymJcK4q10IKj1uvqutp7xKxnfKh6DKRGUkD7MpjkMJqfXP/TthRrc5Q22B9hg8KJWXNkVGpnELfoLD9CEkSORM68tMgjCsyqHzRXnxjU3kZinkAaPGpkviESTSOjIsvjrJpWHytfomK+Fg1v1o+kJfP5wlta+p77eGmF0u25uQVFJY0yPFZZQQHRp3FWR7NYmXUWZzl0S3vec//B6t0QwdJy/EGAAAAAElFTkSuQmCC From 9b4b8a9f41e30311337f7c59d8bb09f9d037828f Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 10 Apr 2024 10:04:35 +0200 Subject: [PATCH 028/141] WIP: almost working conversion dface to brep rhino --- src/gh/diffCheck/diffCheck/df_geometries.py | 108 ++++++++++++++++---- src/gh/diffCheck/diffCheck/diffCheck_app.py | 7 +- 2 files changed, 89 insertions(+), 26 deletions(-) diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 6e0f813d..6a021500 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -47,32 +47,50 @@ def from_rg_point3d(cls, point: rg.Point3d): """ return cls(point.X, point.Y, point.Z) + def to_rg_point3d(self): + """ + Convert the vertex to a Rhino Point3d object + + :return point: The Rhino Point3d object + """ + return rg.Point3d(self.x, self.y, self.z) + @dataclass class DFFace: """ This class represents a face, in diffCheck, a face is a collection of vertices """ - vertices : typing.List[DFVertex] - joint_id : int=None + outer_loop : typing.List[DFVertex] + inner_loops : typing.List[typing.List[DFVertex]] + joint_id : int def __post_init__(self): - if len(self.vertices) < 3: + if len(self.outer_loop) < 3: raise ValueError("A face must have at least 3 vertices") - self.vertices = self.vertices or [] + self.outer_loop = self.outer_loop + self.inner_loops = self.inner_loops or [] - self.joint_id = self.joint_id + self.joint_id = self.joint_id or None self.__is_joint = False self.__id = uuid.uuid4().int + self._hastenonmortise = len(self.inner_loops) > 0 + + self._brepface : rg.BrepFace = None + def __repr__(self): - return f"Face vertices: {len(self.vertices)}" + return f"Face vertices: {len(self.outer_loop)}, Joint: {self.joint_id}, Inner loops: {len(self.inner_loops)}" def __hash__(self): - return hash((tuple(self.vertices), self.joint_id)) + outer_loop = tuple(tuple(vertex.__dict__.values()) for vertex in self.outer_loop) + inner_loops = tuple(tuple(tuple(vertex.__dict__.values()) for vertex in loop) for loop in self.inner_loops) + return hash((outer_loop, inner_loops)) def __eq__(self, other): if isinstance(other, DFFace): - return self.vertices == other.vertices and self.joint_id == other.joint_id + is_outer_loop_equal = self.outer_loop == other.outer_loop + is_inner_loops_equal = self.inner_loops == other.inner_loops + return is_outer_loop_equal and is_inner_loops_equal return False @staticmethod @@ -97,7 +115,8 @@ def from_brep(cls, brep_face: rg.BrepFace, joint_id: int=None): :param joint_id: The joint id :return face: The DFFace object """ - vertices = [] + outer_loop = [] + face_loop = brep_face.OuterLoop face_loop_trims = face_loop.Trims @@ -107,9 +126,27 @@ def from_brep(cls, brep_face: rg.BrepFace, joint_id: int=None): for f_v in face_vertices: vertex = DFVertex(f_v.X, f_v.Y, f_v.Z) - vertices.append(vertex) - - return cls(vertices, joint_id) + outer_loop.append(vertex) + + inner_loops = [] + + if brep_face.Loops.Count > 1: + face_loops = brep_face.Loops + for idx, loop in enumerate(face_loops): + loop_trims = loop.Trims + loop_curve = loop.To3dCurve() + loop_curve = loop_curve.ToNurbsCurve() + loop_vertices = loop_curve.Points + inner_loop = [] + for l_v in loop_vertices: + vertex = DFVertex(l_v.X, l_v.Y, l_v.Z) + inner_loop.append(vertex) + inner_loops.append(inner_loop) + + df_face = cls(outer_loop, inner_loops, joint_id) + df_face._brepface = brep_face + + return df_face def to_brep(self): """ @@ -117,11 +154,19 @@ def to_brep(self): :return brep_face: The Rhino Brep planar face """ - vertices : rg.Point3d = [rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in self.vertices] - polyline = rg.Polyline(vertices) - face_brep = rg.Brep.CreatePlanarBreps([polyline.ToNurbsCurve()])[0] + # if the DFace was created from a brep face, return the brep face + if self._brepface is not None: + return self._brepface + + # FIXME: the rebuilding of breps with multiple loops is not working yet + outer_vertices : rg.Point3d = [rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in self.outer_loop] + outer_polyline = rg.Polyline(outer_vertices) + outer_curve = outer_polyline.ToNurbsCurve() + outer_curve = rg.Curve.CreateControlPointCurve(outer_vertices, 1) + trim_loops.append(outer_curve) + outer_brep = rg.Brep.CreatePlanarBreps(outer_curve, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)[0] - return face_brep + return outer_brep @property def is_joint(self): @@ -135,6 +180,11 @@ def is_joint(self): def id(self): return self.__id + @property + def has_tenonmortise(self): + self._hastenonmortise = len(self.inner_loops) > 0 + return self._hastenonmortise + @dataclass class DFBeam: @@ -189,6 +239,9 @@ def __post_init__(self): self.beams = self.beams self.name = self.name or "Unnamed Assembly" + self._all_jointfaces = [] + self._all_sidefaces = [] + def __repr__(self): return f"Assembly: {self.name}, Beams: {len(self.beams)}" @@ -216,15 +269,15 @@ def from_xml(cls, file_path: str): beam = DFBeam(beam_elem.get("name"), []) beam._DFBeam__id = int(beam_elem.get("id")) for face_elem in beam_elem.findall("Face"): - vertices = [] + outer_loop = [] for vertex_elem in face_elem.findall("Vertex"): vertex = DFVertex( float(vertex_elem.get("x")), float(vertex_elem.get("y")), float(vertex_elem.get("z")) ) - vertices.append(vertex) - face = DFFace(vertices) + outer_loop.append(vertex) + face = DFFace(outer_loop) face._DFFace__id = int(face_elem.get("id")) face._DFFace__is_joint = bool(face_elem.get("is_joint")) face_joint : str = face_elem.get("joint_id") @@ -236,6 +289,7 @@ def from_xml(cls, file_path: str): beams.append(beam) return cls(beams, name) + # FIXME: to be reworked def to_xml(self): """ Dump the assembly to an XML file @@ -256,7 +310,7 @@ def to_xml(self): face_elem.set("is_joint", str(face.is_joint)) face_elem.set("joint_id", str(face.joint_id)) # dfvertices - for vertex in face.vertices: + for vertex in face.outer_loop: vertex_elem = ET.SubElement(face_elem, "Vertex") vertex_elem.set("x", str(vertex.x)) vertex_elem.set("y", str(vertex.y)) @@ -279,4 +333,16 @@ def dump(self, pretty_xml : str, dir: str): file_path = os.path.join(dir, f"{self.name}_{timestamp}.xml") with open(file_path, "w") as f: - f.write(pretty_xml) \ No newline at end of file + f.write(pretty_xml) + + @property + def all_joint_faces(self): + for beam in self.beams: + self._all_jointfaces.extend(beam.joint_faces) + return self._all_jointfaces + + @property + def all_side_faces(self): + for beam in self.beams: + self._all_sidefaces.extend(beam.side_faces) + return self._all_sidefaces \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index 1850d9b6..f9935646 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -39,11 +39,8 @@ o_xml = xml # show the joint/side faces - joints_faces_breps = [] - sides_faces_breps = [] - for beam in beams: - joints_faces_breps.extend([face.to_brep() for face in beam.joint_faces]) - sides_faces_breps.extend([face.to_brep() for face in beam.side_faces]) + joints_faces_breps = [jf.to_brep() for jf in assembly1.all_joint_faces] + sides_faces_breps = [sf.to_brep() for sf in assembly1.all_side_faces] o_joints = joints_faces_breps o_sides = sides_faces_breps \ No newline at end of file From 69262c853945c6c6b5f21cd7448ee659ed7aa57e Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 10 Apr 2024 15:19:32 +0200 Subject: [PATCH 029/141] WIP-CAP: solved DFace-brep convertion, adapting exporting new structure now --- src/gh/diffCheck/diffCheck/df_geometries.py | 190 +++++++++----------- src/gh/diffCheck/diffCheck/diffCheck_app.py | 8 +- src/gh/diffCheck/diffCheck/test.py | 9 + 3 files changed, 98 insertions(+), 109 deletions(-) create mode 100644 src/gh/diffCheck/diffCheck/test.py diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 6a021500..15dc2e28 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -59,38 +59,31 @@ def to_rg_point3d(self): @dataclass class DFFace: """ - This class represents a face, in diffCheck, a face is a collection of vertices + This class represents a face, in diffCheck, a face is a collection of vertices. """ - outer_loop : typing.List[DFVertex] - inner_loops : typing.List[typing.List[DFVertex]] + # just as breps a first outer loop and then inner loops of DFVertices + all_loops : typing.List[typing.List[DFVertex]] joint_id : int def __post_init__(self): - if len(self.outer_loop) < 3: + if len(self.all_loops[0]) < 3: raise ValueError("A face must have at least 3 vertices") - self.outer_loop = self.outer_loop - self.inner_loops = self.inner_loops or [] + self.all_loops = self.all_loops or [] self.joint_id = self.joint_id or None self.__is_joint = False self.__id = uuid.uuid4().int - self._hastenonmortise = len(self.inner_loops) > 0 - - self._brepface : rg.BrepFace = None - def __repr__(self): - return f"Face vertices: {len(self.outer_loop)}, Joint: {self.joint_id}, Inner loops: {len(self.inner_loops)}" + return f"Face id: {len(self.id)}, IsJoint: {self.is_joint} Loops: {len(self.all_loops)}" def __hash__(self): - outer_loop = tuple(tuple(vertex.__dict__.values()) for vertex in self.outer_loop) - inner_loops = tuple(tuple(tuple(vertex.__dict__.values()) for vertex in loop) for loop in self.inner_loops) + outer_loop = tuple(tuple(vertex.__dict__.values()) for vertex in self.all_loops[0]) + inner_loops = tuple(tuple(vertex.__dict__.values()) for loop in self.all_loops[1:] for vertex in loop) return hash((outer_loop, inner_loops)) def __eq__(self, other): if isinstance(other, DFFace): - is_outer_loop_equal = self.outer_loop == other.outer_loop - is_inner_loops_equal = self.inner_loops == other.inner_loops - return is_outer_loop_equal and is_inner_loops_equal + return self.all_loops == other.all_loops return False @staticmethod @@ -115,35 +108,20 @@ def from_brep(cls, brep_face: rg.BrepFace, joint_id: int=None): :param joint_id: The joint id :return face: The DFFace object """ - outer_loop = [] - - face_loop = brep_face.OuterLoop - face_loop_trims = face_loop.Trims - - face_curve_loop = brep_face.OuterLoop.To3dCurve() - face_curve_loop = face_curve_loop.ToNurbsCurve() - face_vertices = face_curve_loop.Points - - for f_v in face_vertices: - vertex = DFVertex(f_v.X, f_v.Y, f_v.Z) - outer_loop.append(vertex) - - inner_loops = [] - - if brep_face.Loops.Count > 1: - face_loops = brep_face.Loops - for idx, loop in enumerate(face_loops): - loop_trims = loop.Trims - loop_curve = loop.To3dCurve() - loop_curve = loop_curve.ToNurbsCurve() - loop_vertices = loop_curve.Points - inner_loop = [] - for l_v in loop_vertices: - vertex = DFVertex(l_v.X, l_v.Y, l_v.Z) - inner_loop.append(vertex) - inner_loops.append(inner_loop) - - df_face = cls(outer_loop, inner_loops, joint_id) + all_loops = [] + + for idx, loop in enumerate(brep_face.Loops): + loop_trims = loop.Trims + loop_curve = loop.To3dCurve() + loop_curve = loop_curve.ToNurbsCurve() + loop_vertices = loop_curve.Points + loop = [] + for l_v in loop_vertices: + vertex = DFVertex(l_v.X, l_v.Y, l_v.Z) + loop.append(vertex) + all_loops.append(loop) + + df_face = cls(all_loops, joint_id) df_face._brepface = brep_face return df_face @@ -154,19 +132,26 @@ def to_brep(self): :return brep_face: The Rhino Brep planar face """ - # if the DFace was created from a brep face, return the brep face - if self._brepface is not None: - return self._brepface + brep_curves = [] + + for loop in self.all_loops: + inner_vertices = [rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in loop] + inner_polyline = rg.Polyline(inner_vertices) + inner_curve = inner_polyline.ToNurbsCurve() + brep_curves.append(inner_curve) + + brep = rg.Brep.CreatePlanarBreps(brep_curves, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)[0] + + return brep - # FIXME: the rebuilding of breps with multiple loops is not working yet - outer_vertices : rg.Point3d = [rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in self.outer_loop] - outer_polyline = rg.Polyline(outer_vertices) - outer_curve = outer_polyline.ToNurbsCurve() - outer_curve = rg.Curve.CreateControlPointCurve(outer_vertices, 1) - trim_loops.append(outer_curve) - outer_brep = rg.Brep.CreatePlanarBreps(outer_curve, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)[0] + def to_mesh(self): + """ + Convert the face to a Rhino Mesh - return outer_brep + :return mesh: The Rhino Mesh object + """ + mesh = self.to_brep().GetMesh(rg.MeshType.Default) + return mesh @property def is_joint(self): @@ -180,11 +165,6 @@ def is_joint(self): def id(self): return self.__id - @property - def has_tenonmortise(self): - self._hastenonmortise = len(self.inner_loops) > 0 - return self._hastenonmortise - @dataclass class DFBeam: @@ -251,43 +231,43 @@ def add_beam(self, beam: DFBeam): def remove_beam(self, beam_id: int): self.beams = [beam for beam in self.beams if beam.id != beam_id] - @classmethod - def from_xml(cls, file_path: str): - """ - Create an assembly from an XML file - - :param file_path: The path to the XML file - :return assembly: The assembly object - """ - # parse the XML file - tree = ET.parse(file_path) - root = tree.getroot() - beams : typing.List[DFBeam] = [] + # @classmethod + # def from_xml(cls, file_path: str): + # """ + # Create an assembly from an XML file + + # :param file_path: The path to the XML file + # :return assembly: The assembly object + # """ + # # parse the XML file + # tree = ET.parse(file_path) + # root = tree.getroot() + # beams : typing.List[DFBeam] = [] - name = root.get("name") - for beam_elem in root.findall("Beam"): - beam = DFBeam(beam_elem.get("name"), []) - beam._DFBeam__id = int(beam_elem.get("id")) - for face_elem in beam_elem.findall("Face"): - outer_loop = [] - for vertex_elem in face_elem.findall("Vertex"): - vertex = DFVertex( - float(vertex_elem.get("x")), - float(vertex_elem.get("y")), - float(vertex_elem.get("z")) - ) - outer_loop.append(vertex) - face = DFFace(outer_loop) - face._DFFace__id = int(face_elem.get("id")) - face._DFFace__is_joint = bool(face_elem.get("is_joint")) - face_joint : str = face_elem.get("joint_id") - if face_joint != "None": - face.joint_id = int(face_joint) - else: - face.joint_id = None - beam.faces.append(face) - beams.append(beam) - return cls(beams, name) + # name = root.get("name") + # for beam_elem in root.findall("Beam"): + # beam = DFBeam(beam_elem.get("name"), []) + # beam._DFBeam__id = int(beam_elem.get("id")) + # for face_elem in beam_elem.findall("Face"): + # outer_loop = [] + # for vertex_elem in face_elem.findall("Vertex"): + # vertex = DFVertex( + # float(vertex_elem.get("x")), + # float(vertex_elem.get("y")), + # float(vertex_elem.get("z")) + # ) + # outer_loop.append(vertex) + # face = DFFace(outer_loop) + # face._DFFace__id = int(face_elem.get("id")) + # face._DFFace__is_joint = bool(face_elem.get("is_joint")) + # face_joint : str = face_elem.get("joint_id") + # if face_joint != "None": + # face.joint_id = int(face_joint) + # else: + # face.joint_id = None + # beam.faces.append(face) + # beams.append(beam) + # return cls(beams, name) # FIXME: to be reworked def to_xml(self): @@ -296,11 +276,11 @@ def to_xml(self): :return xml_string: The pretty XML string """ - root = ET.Element("Assembly") + root = ET.Element("DFAssembly") root.set("name", self.name) # dfbeams for beam in self.beams: - beam_elem = ET.SubElement(root, "Beam") + beam_elem = ET.SubElement(root, "DFBeam") beam_elem.set("name", beam.name) beam_elem.set("id", str(beam.id)) # dffaces @@ -310,11 +290,13 @@ def to_xml(self): face_elem.set("is_joint", str(face.is_joint)) face_elem.set("joint_id", str(face.joint_id)) # dfvertices - for vertex in face.outer_loop: - vertex_elem = ET.SubElement(face_elem, "Vertex") - vertex_elem.set("x", str(vertex.x)) - vertex_elem.set("y", str(vertex.y)) - vertex_elem.set("z", str(vertex.z)) + for loop in face.all_loops: + for vertex in loop: + vertex_elem = ET.SubElement(face_elem, "DFVertex") + vertex_elem.set("x", str(vertex.x)) + vertex_elem.set("y", str(vertex.y)) + vertex_elem.set("z", str(vertex.z)) + tree = ET.ElementTree(root) xml_string = ET.tostring(root, encoding='unicode') dom = parseString(xml_string) diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index f9935646..055284e3 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -2,7 +2,6 @@ import Rhino import Rhino.Geometry as rg -import scriptcontext as sc import os import typing @@ -39,8 +38,7 @@ o_xml = xml # show the joint/side faces - joints_faces_breps = [jf.to_brep() for jf in assembly1.all_joint_faces] - sides_faces_breps = [sf.to_brep() for sf in assembly1.all_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] - o_joints = joints_faces_breps - o_sides = sides_faces_breps \ No newline at end of file + o_test1 = beams[0].faces[7].to_brep() \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/test.py b/src/gh/diffCheck/diffCheck/test.py new file mode 100644 index 00000000..690fcb0d --- /dev/null +++ b/src/gh/diffCheck/diffCheck/test.py @@ -0,0 +1,9 @@ +#! python3 + +import rhinoscriptsyntax as rs +import scriptcontext as sc +import Rhino + +tol=sc.doc.ModelAbsoluteTolerance +breps = Rhino.Geometry.Brep.CreatePlanarBreps(i_crvs, tol) +o_brep = breps[0] \ No newline at end of file From 93a5a0a2243d61b0341c691a7cb23fb36572e6cb Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 10 Apr 2024 15:26:01 +0200 Subject: [PATCH 030/141] ADD: meshing DFace convertion --- src/gh/diffCheck/diffCheck/df_geometries.py | 2 +- src/gh/diffCheck/diffCheck/diffCheck_app.py | 4 +--- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 15dc2e28..eaf9c386 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -150,7 +150,7 @@ def to_mesh(self): :return mesh: The Rhino Mesh object """ - mesh = self.to_brep().GetMesh(rg.MeshType.Default) + mesh = rg.Mesh.CreateFromBrep(self.to_brep())[0] return mesh @property diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index 055284e3..b665917f 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -39,6 +39,4 @@ # 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] - - o_test1 = beams[0].faces[7].to_brep() \ No newline at end of file + o_sides = [sf.to_brep() for sf in assembly1.all_side_faces] \ No newline at end of file From a39080b7640981c1d1e88d798c58ef9bb070f6f3 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 10 Apr 2024 17:07:28 +0200 Subject: [PATCH 031/141] CAP: exporter source code in decent state --- src/gh/diffCheck/diffCheck/df_geometries.py | 69 +- src/gh/diffCheck/diffCheck/diffCheck_app.py | 2 +- src/gh/tester.ghx | 847 ++++++++++++++++++-- 3 files changed, 811 insertions(+), 107 deletions(-) diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index eaf9c386..2097d932 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -231,48 +231,10 @@ def add_beam(self, beam: DFBeam): def remove_beam(self, beam_id: int): self.beams = [beam for beam in self.beams if beam.id != beam_id] - # @classmethod - # def from_xml(cls, file_path: str): - # """ - # Create an assembly from an XML file - - # :param file_path: The path to the XML file - # :return assembly: The assembly object - # """ - # # parse the XML file - # tree = ET.parse(file_path) - # root = tree.getroot() - # beams : typing.List[DFBeam] = [] - - # name = root.get("name") - # for beam_elem in root.findall("Beam"): - # beam = DFBeam(beam_elem.get("name"), []) - # beam._DFBeam__id = int(beam_elem.get("id")) - # for face_elem in beam_elem.findall("Face"): - # outer_loop = [] - # for vertex_elem in face_elem.findall("Vertex"): - # vertex = DFVertex( - # float(vertex_elem.get("x")), - # float(vertex_elem.get("y")), - # float(vertex_elem.get("z")) - # ) - # outer_loop.append(vertex) - # face = DFFace(outer_loop) - # face._DFFace__id = int(face_elem.get("id")) - # face._DFFace__is_joint = bool(face_elem.get("is_joint")) - # face_joint : str = face_elem.get("joint_id") - # if face_joint != "None": - # face.joint_id = int(face_joint) - # else: - # face.joint_id = None - # beam.faces.append(face) - # beams.append(beam) - # return cls(beams, name) - - # FIXME: to be reworked def to_xml(self): """ - Dump the assembly to an XML file + Dump the assembly's meshes to an XML file. On top of the DiffCheck datatypes and structure, + we export the underlaying beams's meshes from Rhino as vertices and faces. :return xml_string: The pretty XML string """ @@ -285,17 +247,26 @@ def to_xml(self): beam_elem.set("id", str(beam.id)) # dffaces for face in beam.faces: - face_elem = ET.SubElement(beam_elem, "Face") + face_elem = ET.SubElement(beam_elem, "DFFace") face_elem.set("id", str(face.id)) face_elem.set("is_joint", str(face.is_joint)) face_elem.set("joint_id", str(face.joint_id)) - # dfvertices - for loop in face.all_loops: - for vertex in loop: - vertex_elem = ET.SubElement(face_elem, "DFVertex") - vertex_elem.set("x", str(vertex.x)) - vertex_elem.set("y", str(vertex.y)) - vertex_elem.set("z", str(vertex.z)) + # export linked mesh + facerhmesh_elem = ET.SubElement(face_elem, "RhMesh") + mesh = face.to_mesh() + mesh_vertices = mesh.Vertices + for idx, vertex in enumerate(mesh_vertices): + facerhmesh_vertex_elem = ET.SubElement(facerhmesh_elem, "RhMeshVertex") + facerhmesh_vertex_elem.set("x", str(vertex.X)) + facerhmesh_vertex_elem.set("y", str(vertex.Y)) + facerhmesh_vertex_elem.set("z", str(vertex.Z)) + mesh_faces = mesh.Faces + for idx, face in enumerate(mesh_faces): + facerhmesh_face_elem = ET.SubElement(facerhmesh_elem, "RhMeshFace") + facerhmesh_face_elem.set("v1", str(face.A)) + facerhmesh_face_elem.set("v2", str(face.B)) + facerhmesh_face_elem.set("v3", str(face.C)) + facerhmesh_face_elem.set("v4", str(face.D)) tree = ET.ElementTree(root) xml_string = ET.tostring(root, encoding='unicode') @@ -304,7 +275,7 @@ def to_xml(self): return pretty_xml - def dump(self, pretty_xml : str, dir: str): + def dump_xml(self, pretty_xml : str, dir: str): """ Dump the pretty XML to a file diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index b665917f..6ceffd75 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -34,7 +34,7 @@ # dump the xml xml : str = assembly1.to_xml() if i_dump: - assembly1.dump(xml, i_export_dir) + assembly1.dump_xml(xml, i_export_dir) o_xml = xml # show the joint/side faces diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index f128de26..d414d451 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - -12 - -118 + 219 + 14 - 1.2750002 + 1.0837501 @@ -68,15 +68,16 @@ - + F:\diffCheck\src\gh\diffCheck\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck\test.py - 2 + 3 - + Robert McNeel & Associates @@ -86,6 +87,14 @@ + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.4.24044.15001 + + + RhinoCodePluginGH, Version=8.4.24044.15001, Culture=neutral, PublicKeyToken=552281e97c755530 8.4.24044.15001 @@ -99,9 +108,9 @@ - 19 + 27 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -561,10 +570,10 @@ - 5 + 6 {0} - + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 @@ -572,17 +581,17 @@ - 7fc04154-255a-413f-a8a1-6ea034e1e779 + aa56315b-2905-4049-8c41-0cc8b39d864b - aa56315b-2905-4049-8c41-0cc8b39d864b + 322f4e22-d195-435e-b290-052cb2318277 - 322f4e22-d195-435e-b290-052cb2318277 + 7fc04154-255a-413f-a8a1-6ea034e1e779 @@ -590,6 +599,11 @@ 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + aeae5255-2a74-4040-9e44-e3aedf934485 + + @@ -611,7 +625,7 @@ Panel false - 0 + 0.8518518507480621 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 1 Double click to edit panel content… @@ -1174,23 +1188,22 @@ - + A panel for custom notes and text values 5262b483-9441-440a-a74d-8b235aad399d Panel false 1 - 76758d37-2a1d-412d-b85b-149ecda8a020 - 1 + 0 Double click to edit panel content… - 414 - 32 + 494 + 71 343 118 @@ -1198,8 +1211,8 @@ 0 0 - 414.04675 - 32.380676 + 494.05792 + 71.25596 @@ -1227,9 +1240,8 @@ - + Allows for customized geometry previews - true true 6f2c8a4b-d787-4606-9170-900f972641c6 Custom Preview @@ -1240,14 +1252,14 @@ - 935 - 81 + 397 + 180 48 44 - 969 - 103 + 431 + 202 @@ -1266,14 +1278,14 @@ - 937 - 83 + 399 + 182 17 20 - 947 - 93 + 409 + 192 @@ -1293,14 +1305,14 @@ - 937 - 103 + 399 + 202 17 20 - 947 - 113 + 409 + 212 @@ -1359,14 +1371,14 @@ - 953 - 153 + 398 + 227 48 44 - 987 - 175 + 432 + 249 @@ -1385,14 +1397,14 @@ - 955 - 155 + 400 + 229 17 20 - 965 - 165 + 410 + 239 @@ -1412,14 +1424,14 @@ - 955 - 175 + 400 + 249 17 20 - 965 - 185 + 410 + 259 @@ -1481,14 +1493,14 @@ - 834 - 103 + 271 + 202 88 20 - 834.6667 - 103.333336 + 271.80634 + 202.06458 @@ -1574,7 +1586,7 @@ false - F:\__TEMP\test\ + F:\diffCheck\temp\ @@ -1659,17 +1671,738 @@ - 856 - 181 + 273 + 249 + 88 + 20 + + + 273.53714 + 249.41264 + + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + f2ae36bd-8b62-496c-ac97-17ab79c53f42 + Custom Preview + Preview + + + + + + + 590 + 220 + 48 + 44 + + + 624 + 242 + + + + + + Geometry to preview + true + 85ca540e-0ffd-46e5-b014-a0ddacc0562b + Geometry + G + false + 0 + + + + + + 592 + 222 + 17 + 20 + + + 602 + 232 + + + + + + + + The material override + 6d95716c-757a-4c8f-8bb0-1685e7e04a52 + Material + M + false + 83adf7c8-580d-4af6-a713-84bf5f8bd2d3 + 1 + + + + + + 592 + 242 + 17 + 20 + + + 602 + 252 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 83adf7c8-580d-4af6-a713-84bf5f8bd2d3 + Colour Swatch + Swatch + false + 0 + + 255;255;0;0 + + + + + + + 465 + 242 88 20 - 856.6275 - 181.76471 + 465.53714 + 242.746 + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 748edcb1-58e5-403f-83e3-9b75ee2319c3 + Button + + false + 0 + + + + + + -320 + 119 + 66 + 22 + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + This allows to run the current active cpython file from vscode to grasshopper. + true + 2 + + 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 + + e0bfe966-26b9-4831-8ac9-46df1627f515 + true + true + true + script-sync cpython + scsy-cpy + + false + false + false + + + + + + -232 + 118 + 111 + 44 + + + -182 + 140 + + + 2 + 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. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 723aff78-609c-4ce8-bc1c-cac8178e9846 + btn + btn + true + 0 + true + 748edcb1-58e5-403f-83e3-9b75ee2319c3 + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + -230 + 120 + 33 + 20 + + + -212 + 130 + + + + + + + + 1 + true + A generic x input. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5Hz+Xw+5HwsF3LIZIuIG0lusUuulMmWHC6c4sYhkVxIkkJcaQ8p4VYxeyvTKmuN2cbume95raVpm723uZrmrTe/9f//877v8zzv92v+qwgyMzP7Xf3Fv8ifVL4urKysPkxOTuLg4AB7e3vY3t7GxsYGVlZWMDs7i/7+frS0tKCsrAyZmZkIDg6GauhX9ar2CeE7YWFhUa5e/HNmZgapqamSKSkpSEpKQkJCAmJjYxEVFYWwsDAB9vf3R15eHtzd3Q3m5ubvjDDfDK29vf3twsICqqqqpDtmRkaGFGKR+Ph4REdHIyIiAiEhIQgMDERlZSWmpqagChgUxpsnqH8IS0vLvqampsfe3l5kZWUhJydHktcsUlJSgpGRESwvL2NgYAChoaFSwM/PD+fn51DNfVZUrRrhXkSQh4fHH8PDwygoKBDg/Px8SV4PDQ2JBh0dHaitrcXp6alcBwUFIS4uDgxvb29qwSkSnyD/For7PY7Kl0mLqQCF5Pj8nTQlJiYK4ObmJnp6eqRAV1cX9Ho9PD094ejo+EUV+cUI+xxlLi4u9zU1NQJCOkhLRUUFxsbGpFB7ezsWFxfl9+zsbBgMBikeGRmJq6srHB0dQTEAX19fKBfqFebbJ2glrOr+Y1paGpgUkkWKi4sxMTEh4Kurq2hra0Nubq48Q6p2dnZE5OnpaaFncHCQTpIi1ERN8ZvCttEo5XucnZ3v+SItSCuyyNzcnABubW0JPSab0gA6nU6s2djYiMfHRzw8PCA5ORlubm5wcnIS4dU1F/W9RlXShYeHi7eZLNLd3S0CEowdknfac3x8HPf396irq5PJbm9vpfvR0VHh39XVlRpIoZiYGG63jgXeK3sZ6G0W4o39/X0pxA1uaGgQe66vr+P6+hqtra1IT0/HxcWFgJ+dnSEgIEDoUUzAwcFBcHx8fDjBzyo1NuSLG8ntrK+vl+OA4nECBinhJKSItNExDBbkdOSd3ZMeTsLNV7o+aWCMt1qtVk/R+vr6npeIBZm85r3m5mbc3NwI+N3dnbiJgKTE1D0Nov7nLjy7SILe5YOdnZ3Y3d0VoehxZlFREdbW1gSYwYOPBb8G57NK7C8K7sUeMFJ4lnCJKN7h4SHm5+dxfHxshAUuLy9FAy8vL6HFBE5hSQ8bsbOzI/cvN5mhplhVD36mQ5aWlnByciLJa3VGUTjpmoKSc1PnClT0UQZ5UDDfPIsYbzgFxycYuzQlQdmxCZgdK/fB1tZW7nOrlY7fP02N8U6NbKCL1PHxnCZQ0mHq2sbGBtbW1rITSjOC//B7wNAqqj7xvKff6RQCkN/S0lLptLy8XL4B1dXV4PlVWFj4+i+aMfh9/fqb+6N8/Tf5fxQazV+PmcVeVawFwQAAAABJRU5ErkJggg== + + 23c7ad3d-125c-4b83-82c2-8433f5ddf85f + i_crvs + i_crvs + true + 1 + true + 84780236-6585-42d5-b303-6e93a13af1b5 + 1 + A generic x input. + 9ba89ec2-5315-435f-a621-b66c5fa2f301 + + + + + + -230 + 140 + 33 + 20 + + + -212 + 150 + + + + + + + + false + The redirected standard output of the component scriptsync. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + bc0b23c8-8d5e-4b50-a901-58cc919b8362 + stdout + stdout + false + 0 + true + 0 + The redirected standard output of the component scriptsync. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + -167 + 120 + 44 + 20 + + + -145 + 130 + + + + + + + + false + Generic example output of the component + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 9bfd0091-47fb-4749-8c63-cc0b3f284701 + o_brep + o_brep + false + 0 + true + 0 + Generic example output of the component + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + -167 + 140 + 44 + 20 + + + -145 + 150 + + + + + + + + + + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path of the file to use the modules
                path_dir = os.path.dirname(path)
                sys.path.insert(0, path_dir)
                self.reload_all_modules(path_dir)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_crvs: System.Collections.Generic.IList[Rhino.Geometry.Curve]):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* + + + + + + + + + + + ac2bc2cb-70fb-4dd5-9c78-7e1ea97fe278 + Geometry + + + + + Contains a collection of generic geometry + 84780236-6585-42d5-b303-6e93a13af1b5 + Geometry + Geo + false + 0 + + + + + + -333 + 170 + 50 + 24 + + + -307.33334 + 182.66667 + + + + + + 1 + + + + + 2 + {0} + + + + + -1 + 9c64993e-eaa5-4262-82d7-af09e513cb01 + Grasshopper.Kernel.Types.GH_Curve + + + + + -1 + 0ea4f4cd-08ba-4f88-96a5-de7e41140054 + Grasshopper.Kernel.Types.GH_Curve + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 18fba923-3fa1-490c-b8ee-734fcc57d7fe + Panel + + false + 0 + 84780236-6585-42d5-b303-6e93a13af1b5 + 1 + Double click to edit panel content… + + + + + + -338 + 216 + 160 + 100 + + 0 + 0 + 0 + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + afb96615-c59a-45c9-9cac-e27acb1c7ca0 + Explode + + + + + Explode a curve into smaller segments. + 6126e53b-589a-4de2-aaff-78a92605cf7a + Explode + Explode + + + + + + -254 + 334 + 65 + 44 + + + -223 + 356 + + + + + + Curve to explode + 6cc5d862-4360-41da-ac8d-152ac750e8d1 + Curve + C + false + 84780236-6585-42d5-b303-6e93a13af1b5 + 1 + + + + + + -252 + 336 + 14 + 20 + + + -243.5 + 346 + + + + + + + + Recursive decomposition until all segments are atomic + 1d0d1653-ec2e-4d70-b716-1eda486a429b + Recursive + R + false + 0 + + + + + + -252 + 356 + 14 + 20 + + + -243.5 + 366 + + + + + + 1 + + + + + 1 + {0} + + + + + true + + + + + + + + + + + 1 + Exploded segments that make up the base curve + c3d12732-08cc-44c5-9bb6-fdce5aea549b + Segments + S + false + 0 + + + + + + -208 + 336 + 17 + 20 + + + -199.5 + 346 + + + + + + + + 1 + Vertices of the exploded segments + 1dcb9d9c-7b1b-4479-9384-2c23132a9733 + Vertices + V + false + 0 + + + + + + -208 + 356 + 17 + 20 + + + -199.5 + 366 + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 420d48fe-ba90-4d69-8c31-c1e6827b9a89 + Panel + + false + 0 + c3d12732-08cc-44c5-9bb6-fdce5aea549b + 1 + Double click to edit panel content… + + + + + + -122 + 280 + 160 + 100 + + 0 + 0 + 0 + + -121.33334 + 280.6667 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + @@ -1681,7 +2414,7 @@ - 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 + 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 From 52aff604e4b51ee0342d0a185c3d1e3b340e910d Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 12 Apr 2024 09:27:17 +0200 Subject: [PATCH 032/141] WIP: working basic imports on script-sync --- deps/eigen | 2 +- src/gh/components/DF_xml_exporter/code.py | 30 +- .../components/DF_xml_exporter/metadata.json | 16 + src/gh/diffCheck/diffCheck/df_geometries.py | 4 +- .../diffCheck/diffCheck/df_joint_detector.py | 3 +- src/gh/diffCheck/diffCheck/diffCheck_app.py | 42 - src/gh/diffCheck/diffCheck/test.py | 9 - src/gh/diffCheck/diffCheck_app.py | 46 + src/gh/tester.ghx | 1615 ++++++++--------- 9 files changed, 831 insertions(+), 936 deletions(-) delete mode 100644 src/gh/diffCheck/diffCheck/diffCheck_app.py delete mode 100644 src/gh/diffCheck/diffCheck/test.py create mode 100644 src/gh/diffCheck/diffCheck_app.py diff --git a/deps/eigen b/deps/eigen index 2620cb93..5226566a 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 2620cb930b7ad87ed1d77a26319739f4b1c86d33 +Subproject commit 5226566a14ddb4d84214c40809531038f087d187 diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py index ef83315e..7a3905d9 100644 --- a/src/gh/components/DF_xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -1,12 +1,6 @@ #! python3 # requirements: diffCheck -""" -This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them to XML. -:param i_breps: list of breps -:param i_export_dir: directory to export the xml -:param i_dump: press to dump the xml -""" import System import typing @@ -16,20 +10,24 @@ from ghpythonlib.componentbase import executingcomponent as component from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly +import diffCheck.df_transformations +import diffCheck.df_joint_detector +import diffCheck.df_util class DFXMLExporter(component): def RunScript(self, i_dump : bool, - i_name : str, + i_assembly_name : str, i_export_dir : str, i_breps : typing.List[Rhino.Geometry.Brep] ): """ - Main function to test the package - :param i_dump: whether to dump the xml - :param i_export_dir: directory to export the xml - :param i_breps: list of breps + This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them 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] = [] @@ -38,9 +36,7 @@ def RunScript(self, beams.append(beam) # assembly - assembly1 = DFAssembly(beams, i_name) - print(assembly1.beams) - print(assembly1) + assembly1 = DFAssembly(beams, i_assembly_name) # dump the xml xml : str = assembly1.to_xml() @@ -48,4 +44,8 @@ def RunScript(self, assembly1.dump(xml, i_export_dir) o_xml = xml - return o_xml \ No newline at end of file + # 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] + + return o_xml, o_joints, o_sides \ No newline at end of file diff --git a/src/gh/components/DF_xml_exporter/metadata.json b/src/gh/components/DF_xml_exporter/metadata.json index cb3b2027..a9d8cda0 100644 --- a/src/gh/components/DF_xml_exporter/metadata.json +++ b/src/gh/components/DF_xml_exporter/metadata.json @@ -70,6 +70,22 @@ "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/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 2097d932..a869149d 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -10,7 +10,7 @@ import xml.etree.ElementTree as ET from xml.dom.minidom import parseString -from df_joint_detector import JointDetector +import diffCheck.df_joint_detector @dataclass @@ -187,7 +187,7 @@ def from_brep(cls, brep): Create a DFBeam from a RhinoBrep object. It also removes duplicates and creates a list of unique faces. """ - faces = JointDetector(brep).run() + faces = diffCheck.df_joint_detector.JointDetector(brep).run() faces = list(set(faces)) beam = cls("Beam", faces) return beam diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index 7713f2a6..44661b6a 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -7,8 +7,7 @@ import df_util import df_transformations -from df_geometries import DFVertex, DFFace - +from df_geometries import DFFace @dataclass class JointDetector(): diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py deleted file mode 100644 index 6ceffd75..00000000 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ /dev/null @@ -1,42 +0,0 @@ -#! python3 - -import Rhino -import Rhino.Geometry as rg - -import os -import typing - -from df_geometries import DFVertex, DFFace, DFBeam, DFAssembly # diffCheck. -import df_transformations # diffCheck. -import df_joint_detector # diffCheck. -import df_util # diffCheck. - -from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML - -if __name__ == "__main__": - """ - Main function to test the package - :param i_breps: list of breps - :param i_export_dir: directory to export the xml - :param i_dump: whether to dump the xml - """ - # 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) - print(assembly1.beams) - print(assembly1) - - # 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] \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/test.py b/src/gh/diffCheck/diffCheck/test.py deleted file mode 100644 index 690fcb0d..00000000 --- a/src/gh/diffCheck/diffCheck/test.py +++ /dev/null @@ -1,9 +0,0 @@ -#! python3 - -import rhinoscriptsyntax as rs -import scriptcontext as sc -import Rhino - -tol=sc.doc.ModelAbsoluteTolerance -breps = Rhino.Geometry.Brep.CreatePlanarBreps(i_crvs, tol) -o_brep = breps[0] \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py new file mode 100644 index 00000000..9b33557f --- /dev/null +++ b/src/gh/diffCheck/diffCheck_app.py @@ -0,0 +1,46 @@ +#! python3 + +import Rhino +import Rhino.Geometry as rg + +import os +import typing + +import diffCheck + +# import diffCheck.df_joint_detector # diffCheck. +import diffCheck.df_geometries # diffCheck. +# # from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly # diffCheck. +# # import diffCheck.df_transformations # diffCheck. +# # import diffCheck.df_util # diffCheck. + + +if __name__ == "__main__": + joint_detector = diffCheck.df_joint_detector.JointDetector(brep=i_breps[0]).run() + print(type(joint_detector)) + # print(joint_detector.run()) + beam = diffCheck.df_geometries.DFBeam.from_brep(i_breps[0]) + """ + Main function to test the package + :param i_breps: list of breps + :param i_export_dir: directory to export the xml + :param i_dump: whether to dump the xml + """ + # beams + beams : typing.List[diffCheck.df_geometries.DFBeam] = [] + for brep in i_breps: + beam = diffCheck.df_geometries.DFBeam.from_brep(brep) + beams.append(beam) + + # assembly + assembly1 = diffCheck.df_geometries.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] \ No newline at end of file diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index d414d451..97129e02 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 219 - 14 + 30 + -86 - 1.0837501 + 1.5 @@ -69,35 +69,27 @@ - F:\diffCheck\src\gh\diffCheck\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py F:\diffCheck\src\gh\diffCheck\diffCheck\test.py - 3 + 2 - + Robert McNeel & Associates 00000000-0000-0000-0000-000000000000 Grasshopper - 8.4.24044.15001 + 8.5.24072.13001 - - Robert McNeel & Associates - 00000000-0000-0000-0000-000000000000 - Grasshopper - 8.4.24044.15001 - - - - RhinoCodePluginGH, Version=8.4.24044.15001, Culture=neutral, PublicKeyToken=552281e97c755530 - 8.4.24044.15001 + RhinoCodePluginGH, Version=8.5.24072.13001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.5.24072.13001 066d0a87-236f-4eae-a0f4-9e42f5327962 RhinoCodePluginGH @@ -108,9 +100,9 @@ - 27 + 25 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -206,9 +198,9 @@ true - Converts to collection of text fragments + No conversion - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== e0ef2066-70a4-441f-906b-8a4afddb0692 i_export_dir @@ -219,7 +211,7 @@ 77c76654-6be3-4843-b564-afe44705740d 1 - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + 6a184b65-baa3-42d1-a548-3915b401de53 @@ -277,9 +269,9 @@ true - Converts to collection of text fragments + No conversion - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== d9632669-508e-4a03-b9bc-a5d740ef546f i_assembly_name @@ -290,7 +282,7 @@ 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 1 - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + 6a184b65-baa3-42d1-a548-3915b401de53 @@ -484,7 +476,7 @@ - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name: str,
            i_dump: bool):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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)
 + #! python3
# r: numpy

from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name,
            i_dump: bool):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -634,8 +626,8 @@ - 329 - -243 + 445 + -256 494 292 @@ -643,8 +635,8 @@ 0 0 - 329.48257 - -242.18234 + 445.17487 + -255.70482 @@ -672,15 +664,14 @@ - + A panel for custom notes and text values d5d04f93-3b13-4fa3-8644-243c03f9a7e8 Panel false 0.2985713966190815 - bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e - 1 + 0 Double click to edit panel content… @@ -720,33 +711,51 @@ - 3ede854e-c753-40eb-84cb-b48008f14fd4 - Text + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel - - Contains a collection of text fragments - bc61f3bc-d42e-4ab9-9cde-bfa5df8d625e - Text - Txt + + A panel for custom notes and text values + 63a2f4e1-c253-4fc3-9148-719323b802e1 + Panel + false - a7582614-58af-4e8e-ac5d-40e739284db1 + 0 + 178951a0-3c74-4810-aef0-87cc45b0502c 1 + Double click to edit panel content… - + - + - 375 - 373 - 50 - 24 + 627 + 289 + 411 + 166 + 0 + 0 + 0 - 400.89478 - 385.76862 + 627.30396 + 289.70813 + + + + + + + 255;213;217;232 + true + true + true + false + false + true @@ -754,212 +763,52 @@ - - c9b2d725-6f87-4b07-af90-bd9aefef68eb - 066d0a87-236f-4eae-a0f4-9e42f5327962 - Exporter to xml + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel - - - true - true - 2 - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= - - 37244b65-1555-4735-bf3f-ab0481941fea - true - true - true - Exporter to xml - XMLout - - false - false - false + + A panel for custom notes and text values + 5262b483-9441-440a-a74d-8b235aad399d + Panel + + false + 1 + 0 + Double click to edit panel content… - + - + - 227 - 353 - 135 - 64 + 494 + 71 + 343 + 118 + 0 + 0 + 0 - 307 - 385 + 494.05792 + 71.25596 - - - 3 - 08908df5-fa14-4982-9ab2-1aa0927566aa - 08908df5-fa14-4982-9ab2-1aa0927566aa - 08908df5-fa14-4982-9ab2-1aa0927566aa - 1 - 08908df5-fa14-4982-9ab2-1aa0927566aa - - - - - true - Press button to export xml - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC - - 5c36c839-5c70-4ab8-a9fc-6cacff1c6955 - i_dump - i_dump - true - 0 - true - 83363e37-e611-4b77-bcde-c28b03d7ee96 - 1 - Press button to export xml - d60527f5-b5af-4ef6-8970-5f96fe412559 - - - - - - 229 - 355 - 63 - 20 - - - 262 - 365 - - - - - - - - true - The directors where to export the xml file. - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== - - eec8c89f-334e-4696-b34e-61b913c98340 - i_export_dir - i_export_dir - true - 0 - true - 2bba20ed-c34b-45cd-b237-6fb28c1269ad - 1 - The directors where to export the xml file. - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 - - - - - - 229 - 375 - 63 - 20 - - - 262 - 385 - - - - - - - - 1 - true - The breps of the structure. - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= - - 1fbd84e2-0cb6-4f71-a6ce-ef8bd20d11f0 - i_breps - i_breps - true - 1 - true - 35b72f16-8924-45e9-9eff-a5eea8982d94 - 1 - The breps of the structure. - 2ceb0405-fdfe-403d-a4d6-8786da45fb9d - - - - - - 229 - 395 - 63 - 20 - - - 262 - 405 - - - - - - - - false - The string of xml to be exported. - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - - a7582614-58af-4e8e-ac5d-40e739284db1 - o_xml - o_xml - false - 0 - true - 0 - The string of xml to be exported. - 6a184b65-baa3-42d1-a548-3915b401de53 - - - - - - 322 - 355 - 38 - 60 - - - 341 - 385 - - - - - - - - - - IyEgcHl0aG9uMwojIHJlcXVpcmVtZW50czogZGlmZkNoZWNrCiIiIgpUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgoKOnBhcmFtIGlfYnJlcHM6IGxpc3Qgb2YgYnJlcHMKOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCjpwYXJhbSBpX2R1bXA6IHByZXNzIHRvIGR1bXAgdGhlIHhtbAoiIiIKaW1wb3J0IFN5c3RlbQppbXBvcnQgdHlwaW5nCgppbXBvcnQgUmhpbm8KaW1wb3J0IFJoaW5vLkdlb21ldHJ5IGFzIHJnCgpmcm9tIGdocHl0aG9ubGliLmNvbXBvbmVudGJhc2UgaW1wb3J0IGV4ZWN1dGluZ2NvbXBvbmVudCBhcyBjb21wb25lbnQKCmZyb20gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMgaW1wb3J0IERGQmVhbSwgREZBc3NlbWJseQoKCmNsYXNzIFhNTEV4cG9ydGVyKGNvbXBvbmVudCk6CiAgICBkZWYgUnVuU2NyaXB0KHNlbGYsCiAgICAgICAgICAgIGlfZHVtcDogYm9vbCwKICAgICAgICAgICAgaV9leHBvcnRfZGlyOiBzdHIsCiAgICAgICAgICAgIGlfYnJlcHM6IFN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLklMaXN0W1JoaW5vLkdlb21ldHJ5LkJyZXBdKToKICAgICAgICAiIiIKICAgICAgICBNYWluIGZ1bmN0aW9uIHRvIHRlc3QgdGhlIHBhY2thZ2UKICAgICAgICA6cGFyYW0gaV9kdW1wOiB3aGV0aGVyIHRvIGR1bXAgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zIDogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCAiQXNzZW1ibHkxIikKICAgICAgICBwcmludChhc3NlbWJseTEuYmVhbXMpCiAgICAgICAgcHJpbnQoYXNzZW1ibHkxKQoKICAgICAgICAjIGR1bXAgdGhlIHhtbAogICAgICAgIHhtbCA6IHN0ciA9IGFzc2VtYmx5MS50b194bWwoKQogICAgICAgIGlmIGlfZHVtcDoKICAgICAgICAgICAgYXNzZW1ibHkxLmR1bXAoeG1sLCBpX2V4cG9ydF9kaXIpCiAgICAgICAgb194bWwgPSB4bWwKCiAgICAgICAgcmV0dXJuIG9feG1s - S + + + + 255;213;217;232 + + true + true + true + false + false + true - - - - *.*.python - 3.* - - - @@ -967,276 +816,8 @@ - 919e146f-30ae-4aae-be34-4d72f555e7da - Brep - - - - - Contains a collection of Breps (Boundary REPresentations) - true - 35b72f16-8924-45e9-9eff-a5eea8982d94 - Brep - Brep - false - 0 - - - - - - 156 - 398 - 50 - 24 - - - 181.23218 - 410.9286 - - - - - - 1 - - - - - 3 - {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 - - - - - - - - - - - - - 06953bda-1d37-4d58-9b38-4b3c74e54c8f - File Path - - - - - Contains a collection of file paths - false - All files|*.* - 2bba20ed-c34b-45cd-b237-6fb28c1269ad - File Path - Path - false - 0 - - - - - - 156 - 372 - 50 - 24 - - - 181.49844 - 384.07333 - - - - - - 1 - - - - - 1 - {0} - - - - - false - F:\__TEMP\test\ - - - - - - - - - - - - - a8b97322-2d53-47cd-905e-b932c3ccd74e - Button - - - - - Button object with two values - False - True - 83363e37-e611-4b77-bcde-c28b03d7ee96 - Button - dump! - false - 0 - - - - - - 104 - 344 - 102 - 22 - - - - - - - - - - 59e0b89a-e487-49f8-bab8-b5bab16be14c - Panel - - - - - A panel for custom notes and text values - 63a2f4e1-c253-4fc3-9148-719323b802e1 - Panel - - false - 0 - 178951a0-3c74-4810-aef0-87cc45b0502c - 1 - Double click to edit panel content… - - - - - - 627 - 289 - 411 - 166 - - 0 - 0 - 0 - - 627.30396 - 289.70813 - - - - - - - 255;213;217;232 - - true - true - true - false - false - true - - - - - - - - - 59e0b89a-e487-49f8-bab8-b5bab16be14c - Panel - - - - - A panel for custom notes and text values - 5262b483-9441-440a-a74d-8b235aad399d - Panel - - false - 1 - 0 - Double click to edit panel content… - - - - - - 494 - 71 - 343 - 118 - - 0 - 0 - 0 - - 494.05792 - 71.25596 - - - - - - - 255;213;217;232 - - true - true - true - false - false - true - - - - - - - - - 537b0419-bbc2-4ff4-bf08-afe526367b2c - Custom Preview + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview @@ -1352,7 +933,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -1471,7 +1052,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1493,14 +1074,14 @@ - 271 - 202 + 276 + 220 88 20 - 271.80634 - 202.06458 + 276.14133 + 220.3679 @@ -1508,7 +1089,7 @@ - + a8b97322-2d53-47cd-905e-b932c3ccd74e Button @@ -1540,7 +1121,7 @@ - + 06953bda-1d37-4d58-9b38-4b3c74e54c8f File Path @@ -1597,7 +1178,7 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -1649,7 +1230,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1686,7 +1267,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -1804,7 +1385,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1841,260 +1422,102 @@ - + - a8b97322-2d53-47cd-905e-b932c3ccd74e - Button + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep - Button object with two values - False - True - 748edcb1-58e5-403f-83e3-9b75ee2319c3 - Button - + Contains a collection of Breps (Boundary REPresentations) + true + 39d914fb-05fc-4c33-93a8-98326df3e596 + true + Brep + Brep false 0 - - - - - -320 - 119 - 66 - 22 - - - - - - - - - - c9b2d725-6f87-4b07-af90-bd9aefef68eb - 066d0a87-236f-4eae-a0f4-9e42f5327962 - script-sync cpython - - - - - This allows to run the current active cpython file from vscode to grasshopper. - true - 2 - - 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 - - e0bfe966-26b9-4831-8ac9-46df1627f515 - true - true - true - script-sync cpython - scsy-cpy - - false - false - false - - + - -232 - 118 - 111 - 44 + 159 + 656 + 50 + 24 - -182 - 140 + 184.61072 + 668.0817 - - - 2 - 08908df5-fa14-4982-9ab2-1aa0927566aa - 08908df5-fa14-4982-9ab2-1aa0927566aa - 2 - 08908df5-fa14-4982-9ab2-1aa0927566aa - 08908df5-fa14-4982-9ab2-1aa0927566aa + + + 1 - - - - true - Connect a button to open a file dialog to select a cpython file to run. - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC - - 723aff78-609c-4ce8-bc1c-cac8178e9846 - btn - btn - true - 0 - true - 748edcb1-58e5-403f-83e3-9b75ee2319c3 - 1 - Connect a button to open a file dialog to select a cpython file to run. - d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + 6 + {0} - - - - - -230 - 120 - 33 - 20 - - - -212 - 130 - + + + + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 - - - - - 1 - true - A generic x input. - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5Hz+Xw+5HwsF3LIZIuIG0lusUuulMmWHC6c4sYhkVxIkkJcaQ8p4VYxeyvTKmuN2cbume95raVpm723uZrmrTe/9f//877v8zzv92v+qwgyMzP7Xf3Fv8ifVL4urKysPkxOTuLg4AB7e3vY3t7GxsYGVlZWMDs7i/7+frS0tKCsrAyZmZkIDg6GauhX9ar2CeE7YWFhUa5e/HNmZgapqamSKSkpSEpKQkJCAmJjYxEVFYWwsDAB9vf3R15eHtzd3Q3m5ubvjDDfDK29vf3twsICqqqqpDtmRkaGFGKR+Ph4REdHIyIiAiEhIQgMDERlZSWmpqagChgUxpsnqH8IS0vLvqampsfe3l5kZWUhJydHktcsUlJSgpGRESwvL2NgYAChoaFSwM/PD+fn51DNfVZUrRrhXkSQh4fHH8PDwygoKBDg/Px8SV4PDQ2JBh0dHaitrcXp6alcBwUFIS4uDgxvb29qwSkSnyD/For7PY7Kl0mLqQCF5Pj8nTQlJiYK4ObmJnp6eqRAV1cX9Ho9PD094ejo+EUV+cUI+xxlLi4u9zU1NQJCOkhLRUUFxsbGpFB7ezsWFxfl9+zsbBgMBikeGRmJq6srHB0dQTEAX19fKBfqFebbJ2glrOr+Y1paGpgUkkWKi4sxMTEh4Kurq2hra0Nubq48Q6p2dnZE5OnpaaFncHCQTpIi1ERN8ZvCttEo5XucnZ3v+SItSCuyyNzcnABubW0JPSab0gA6nU6s2djYiMfHRzw8PCA5ORlubm5wcnIS4dU1F/W9RlXShYeHi7eZLNLd3S0CEowdknfac3x8HPf396irq5PJbm9vpfvR0VHh39XVlRpIoZiYGG63jgXeK3sZ6G0W4o39/X0pxA1uaGgQe66vr+P6+hqtra1IT0/HxcWFgJ+dnSEgIEDoUUzAwcFBcHx8fDjBzyo1NuSLG8ntrK+vl+OA4nECBinhJKSItNExDBbkdOSd3ZMeTsLNV7o+aWCMt1qtVk/R+vr6npeIBZm85r3m5mbc3NwI+N3dnbiJgKTE1D0Nov7nLjy7SILe5YOdnZ3Y3d0VoehxZlFREdbW1gSYwYOPBb8G57NK7C8K7sUeMFJ4lnCJKN7h4SHm5+dxfHxshAUuLy9FAy8vL6HFBE5hSQ8bsbOzI/cvN5mhplhVD36mQ5aWlnByciLJa3VGUTjpmoKSc1PnClT0UQZ5UDDfPIsYbzgFxycYuzQlQdmxCZgdK/fB1tZW7nOrlY7fP02N8U6NbKCL1PHxnCZQ0mHq2sbGBtbW1rITSjOC//B7wNAqqj7xvKff6RQCkN/S0lLptLy8XL4B1dXV4PlVWFj4+i+aMfh9/fqb+6N8/Tf5fxQazV+PmcVeVawFwQAAAABJRU5ErkJggg== - - 23c7ad3d-125c-4b83-82c2-8433f5ddf85f - i_crvs - i_crvs - true - 1 - true - 84780236-6585-42d5-b303-6e93a13af1b5 - 1 - A generic x input. - 9ba89ec2-5315-435f-a621-b66c5fa2f301 - - - - - - -230 - 140 - 33 - 20 - - - -212 - 150 - + + + 322f4e22-d195-435e-b290-052cb2318277 - - - - - false - The redirected standard output of the component scriptsync. - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - - bc0b23c8-8d5e-4b50-a901-58cc919b8362 - stdout - stdout - false - 0 - true - 0 - The redirected standard output of the component scriptsync. - 6a184b65-baa3-42d1-a548-3915b401de53 - - - - - - -167 - 120 - 44 - 20 - - - -145 - 130 - + + + aa56315b-2905-4049-8c41-0cc8b39d864b - - - - - false - Generic example output of the component - - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - - 9bfd0091-47fb-4749-8c63-cc0b3f284701 - o_brep - o_brep - false - 0 - true - 0 - Generic example output of the component - 6a184b65-baa3-42d1-a548-3915b401de53 - - - - - - -167 - 140 - 44 - 20 - - - -145 - 150 - + + + 7fc04154-255a-413f-a8a1-6ea034e1e779 + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + aeae5255-2a74-4040-9e44-e3aedf934485 - - - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path of the file to use the modules
                path_dir = os.path.dirname(path)
                sys.path.insert(0, path_dir)
                self.reload_all_modules(path_dir)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_crvs: System.Collections.Generic.IList[Rhino.Geometry.Curve]):
        """ 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(btn)

        # 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())
        self.is_success = True
        return

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* - - - - - + - ac2bc2cb-70fb-4dd5-9c78-7e1ea97fe278 - Geometry + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path - - Contains a collection of generic geometry - 84780236-6585-42d5-b303-6e93a13af1b5 - Geometry - Geo + + Contains a collection of file paths + false + All files|*.* + 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 + true + File Path + Path false 0 @@ -2102,14 +1525,14 @@ - -333 - 170 + 159 + 629 50 24 - -307.33334 - 182.66667 + 184.87698 + 641.2265 @@ -2120,22 +1543,14 @@ - 2 + 1 {0} - + - - -1 - 9c64993e-eaa5-4262-82d7-af09e513cb01 - Grasshopper.Kernel.Types.GH_Curve - - - - - -1 - 0ea4f4cd-08ba-4f88-96a5-de7e41140054 - Grasshopper.Kernel.Types.GH_Curve + + false + F:\__TEMP\test\ @@ -2146,7 +1561,40 @@ - + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 66637ff1-037c-4e4c-ba3a-0930de00a3ea + true + Button + dump! + false + 0 + + + + + + 106 + 569 + 102 + 22 + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -2155,27 +1603,31 @@ A panel for custom notes and text values - 18fba923-3fa1-490c-b8ee-734fcc57d7fe + 66ce41af-42cf-48a0-871c-5d06b68b6ae7 + true Panel false 0 - 84780236-6585-42d5-b303-6e93a13af1b5 - 1 - Double click to edit panel content… + 0 + AssemblyTest - + - -338 - 216 - 160 - 100 + 111 + 602 + 102 + 20 0 0 0 + + 111.36775 + 602.9323 + @@ -2195,82 +1647,89 @@ - + - afb96615-c59a-45c9-9cac-e27acb1c7ca0 - Explode + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview - - Explode a curve into smaller segments. - 6126e53b-589a-4de2-aaff-78a92605cf7a - Explode - Explode + + Allows for customized geometry previews + true + 649b3c81-ba59-413f-ad42-15bca79f15e2 + true + Custom Preview + Preview + - + - -254 - 334 - 65 + 602 + 647 + 48 44 - -223 - 356 + 636 + 669 - - Curve to explode - 6cc5d862-4360-41da-ac8d-152ac750e8d1 - Curve - C + + Geometry to preview + true + 799c43bc-4b78-4d8f-a2ed-f604ed2b1ddb + true + Geometry + G false - 84780236-6585-42d5-b303-6e93a13af1b5 + 5769b0e3-b5fa-46e5-8b49-25088b83a917 1 - -252 - 336 - 14 + 604 + 649 + 17 20 - -243.5 - 346 + 614 + 659 - - Recursive decomposition until all segments are atomic - 1d0d1653-ec2e-4d70-b716-1eda486a429b - Recursive - R + + The material override + 07e88719-b77c-4ac3-a12c-cc329aefe255 + true + Material + M false - 0 + c0aa2559-2d8c-481d-a41d-c02943a5f981 + 1 - -252 - 356 - 14 + 604 + 669 + 17 20 - -243.5 - 366 + 614 + 679 @@ -2286,8 +1745,18 @@ - - true + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 @@ -2296,113 +1765,529 @@ - - - 1 - Exploded segments that make up the base curve - c3d12732-08cc-44c5-9bb6-fdce5aea549b - Segments - S + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 4d39988a-2c7d-4bb0-9261-f460ec916be1 + true + Custom Preview + Preview + + + + + + + 603 + 694 + 48 + 44 + + + 637 + 716 + + + + + + Geometry to preview + true + 8d9e002d-b2f2-4476-8f21-adea36efcb4a + true + Geometry + G false - 0 + 0cd168ad-f650-4b68-87a8-b45f32a6dbfc + 1 - -208 - 336 + 605 + 696 17 20 - -199.5 - 346 + 615 + 706 - - - 1 - Vertices of the exploded segments - 1dcb9d9c-7b1b-4479-9384-2c23132a9733 - Vertices - V + + + The material override + 58e8f37f-40e5-4060-83b0-c395fb2daf6d + true + Material + M false - 0 + 28b353a5-44f7-436e-8a36-957623e89dde + 1 - + - -208 - 356 + 605 + 716 17 20 - -199.5 - 366 + 615 + 726 + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + - + - 59e0b89a-e487-49f8-bab8-b5bab16be14c - Panel + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch - - A panel for custom notes and text values - 420d48fe-ba90-4d69-8c31-c1e6827b9a89 - Panel - + + Colour (palette) swatch + c0aa2559-2d8c-481d-a41d-c02943a5f981 + true + Colour Swatch + Swatch false - 0 - c3d12732-08cc-44c5-9bb6-fdce5aea549b - 1 - Double click to edit panel content… + 0 + + 255;128;0;255 + - + - + - -122 - 280 - 160 - 100 + 478 + 670 + 88 + 20 - 0 - 0 - 0 - -121.33334 - 280.6667 + 478.32407 + 670.98126 - - - - 255;213;217;232 + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 28b353a5-44f7-436e-8a36-957623e89dde + true + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 480 + 718 + 88 + 20 + + + 480.05487 + 718.3294 + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 65e17a0f-52e4-4f2c-938f-4153c4d95177 + true + true + true + true + DFXMLExporter + XMLout + + false + false + false + + + + + + 260 + 588 + 171 + 84 + + + 367 + 630 - true - true - true - false - false - true + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 9a169d71-5230-4a49-bd7a-e2f72347ebf0 + true + i_dump + i_dump + true + 0 + true + 66637ff1-037c-4e4c-ba3a-0930de00a3ea + 1 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 262 + 590 + 90 + 20 + + + 308.5 + 600 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + e20c6b9b-9964-45e2-8b3a-f3526ce7d7a5 + true + i_assembly_name + i_assembly_name + true + 0 + true + 66ce41af-42cf-48a0-871c-5d06b68b6ae7 + 1 + The name of the assembly to export. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 262 + 610 + 90 + 20 + + + 308.5 + 620 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 74ce08ea-85ea-42f1-9b6f-e415953f6a3d + true + i_export_dir + i_export_dir + true + 0 + true + 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 + 1 + The directors where to export the xml file. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 262 + 630 + 90 + 20 + + + 308.5 + 640 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + d700b88b-9d37-47c0-a242-80e85b5d4e00 + true + i_breps + i_breps + true + 1 + true + 39d914fb-05fc-4c33-93a8-98326df3e596 + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 262 + 650 + 90 + 20 + + + 308.5 + 660 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + d4570a62-ba44-499e-a550-0cf9fa169720 + true + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 382 + 590 + 47 + 26 + + + 405.5 + 603.3333 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 5769b0e3-b5fa-46e5-8b49-25088b83a917 + true + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 382 + 616 + 47 + 27 + + + 405.5 + 630 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 0cd168ad-f650-4b68-87a8-b45f32a6dbfc + true + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 6a184b65-baa3-42d1-a548-3915b401de53 + + + + + + 382 + 643 + 47 + 27 + + + 405.5 + 656.6666 + + + + + + + + + + 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 + S + + + + + *.*.python + 3.* + + + + @@ -2414,7 +2299,7 @@ - iVBORw0KGgoAAAANSUhEUgAAAOEAAACWCAIAAACn9nhUAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAF8xSURBVHhe7b0HdN3WmajrmVl33TWZN28mN/fFdjKpTvXEmSQziaviEhdZLnFvsqrVRZFqFFXYKfbey+FhOefwVPbee++9d/KwU7Ikt1S+DwBFU5RIUYpsywz/9Qva2NjY2AA+/AUHBO5Yl3X5EsjcuqzL7SqfMjqyLqKMjo4MDY929c1EKQyVtV0dPdNtXRPt3ZMNLcONrcOUWzvHO3unmaWSAi1bOsYosEhq2do13jd0oa5pQBaha+2caOsWVkFpSbOmttGOnimatXdP0Z5y7+D7TCnTD20oS7PN7Uaa9Q69z1qs3tI5Rn1Dy1Bb16Q0BhrIowylle2dvTPUM1RW7xk8L64ibKu7f7a9Z6pn4LzUnj67+mZTM0pVmhRGKI2ne+Bcd/85aRhSDW3YLoNhi6wobnQ4TK4tqWijkg01twu7QG+s2DPw6bpsTtqWUClsnZ5nacYs3TJFxaXnWQVllg0xy6Fg2tU/u7BUmBUPxTqj1xYwHRmdjIgyVNV2L2aUM5RTUJtbUCec++4pjnt2Xk1sQi7Y6WIzK2u7gSY5rbilw5iQUkBZa8iIVMRxrDOyK8qrOwtKGqnnzGXkVBYUN7Z2jiWnFdGtWp9W29ifnF4cl5RXXd8XpUyobRpISM5PzSxtbhtV61JLK9qy86ozciq6+qYZCdulfWJqYW1Df2xibkVNV2ffTO/geQbmFxCZnV+j0afJo2Kr6nqS0orYOmNLSS9h8IkphayelVeVX9xQWNrkFxiZlVsVHZOoVCfVNPTRjMEwVJpRYPBcZmw3IbmgvnmQerYrsQXEKRmlRWXNbJeDw/WQnlXO3qVnV8Ql5vYNvc/IK2o60zLLsvKquWa4KgpLmmITcuiKa4NDxNhgnYJ0lCgzTckoGRi5yJir63t1sVmZOZU19X3rjC4rExPjqhhdRc0VjLZ1TmTmVhniczjQWA5IBVlHFz9h6uwDB5whb79w6pXq5KranoKSJuwc58PW3j0nv1alTfENiAQRBydvbFJsYo5/YFRuYZ29oxenE8TDowz0f9bZp6isJThMFREdy6Z9AyJUmmTK9mc96Wpg5BL9U0nPnGAffzlnd3D0g/7hi9V1vQAH3DAtk2trGwegH55cPYJoTAEW6xoHgkKVQaGqqrreGG0KVwWwRqsS0rPLbezcYrSpUEV7QGdzEJxXWO/k6tfUNqKISeQIYN7ACBYZc3F5S9/wBcaTV1Rva+/BHkGqm2cwg2QH2aOAoGgPn9D4pHxHZ1+ALixt5srB6rNuWWW7WpcWHBYD+rCbmlnm4xfOjnAls92C4gb/oGiMPdfVOqPLCoyq1Vcx2jWRmFoUGKIEUEN8NsaMc+nuGZyWVRYqUzP1C4wyPXwSOwo6WErJ2hWXt27ZtgeDmpRaxJnGXJ04ZYdBDQxRmB05hbUAR8gARHmkoby6wz8oiiCBc+zs5o/5CQ3XcLaSUgtPW56FYwoMxtrW1ds3PL+ogZaAxYnnChkyfqiPz8YSQyf2ldFiVrGy2EVPnzDWhWxWYUORynj2K14w271Vdd1gzZjhjEFiOL18w6AQjrPzq+GPHSyv6vDylQEffqOypguqjplbM0JsJyYZy3f8hLU+LgumGTwOYeeug8IFkJjr6OLL5ixO2ccl5kVGx8IlUO5474A+PovBnDhpy7C5QrC7dEIN+8JSji3HysMrhE2sM7qsXJNR0TsXcyKZ5aDjAXFPMIeZwTdxCgWnH5fJiQ+WxeQV1jW2jlDZP3KRtXLya+ADwvCYWFCMELEX60p+jWaAqNGnM6uISYIJbBIo4G3ZHAhyMQAZNs/VPRBLVlLeSoxR09CP4WRdTBTOl8iytLINX4zjZkW6CpVpsKl0FZ+cTw0XA9Bn5VbjfHHQJRWt7Eh1XQ/XEkvBRdyvXJBtaBacLy6YHQRlNi2a3h7wBUTCFeFiqOvBCUAzxpWhskeELjTG10MYviUzt5IrBPtNn+w7MQwc4wQYDAMWD1omIT5LOW4wSidE0pj24rIWrisOGpfuOqPLisRo5ZWMAqUY+b3PKZSSEjzd8NhHxHx4PeDgBDBLPc6XhIAVpXU5iyyimZQHcBYpsIggkv6ZZUq3FNqEXEpQlgppTf/syMQnLCKqowfOK52zLp3j3MWuLlCDwg1rka4RKKMsYoQ0ozHs0gNLGS2VtGQ8bV3zWRQtUVaR2jAkClLPYipzDm6YFdclUxwSxzbJUsYsdC5mRcJQxVGxLtcenYAm25V2U1w6y5R6ca+FlI4+6VncLjmTcIiYXVgqZH5iJ+uMLiswGqPWLrajGEXsFkYO94oBcHLxI6PCwuHKsRaYT4In7A0Go6l9lDKrJKYUYB05Z5wPTjBRF75eSoo5eVgOrAUnUjzrAs2cbwwhPWNLiBo1oiUjkiP/wMhhmegE38pW6BOtbx6SR+kxRVKH1MujY2lAP5zmytouwlAMJ6BL/f/tyoaW1HzWus7osnI1o9hRpgRbYXIt6NjYu+GMCBbPWDnhKIn8WjrHiaiOW9gQdZ08ZU/YitMkHgUaTAg8GUgOSIdLm7EQnGwcOj2wCPIATtoK4QRulOuBK8HHT07yZHbkJJ0QBuAiofCAyfHAUKW7V4iVjSvNpLAYKDGreGeuCq4fbB7WCB9KiMxakqn7kuo6o8vKcoySi4SGqwnzbezdyWmI8EgLyN/tHDwJwsi+nV39MXhSgqw1pNOSHJakFTtHGEoDgi3gw7UBk7dfOOGEX2AkW6Fz2CVLoCtiULolO+Z6OOvsDaCsKCVJdmc9yUKAGzpB1s7Bg0BQqU4mcCyr6uDCYDBYay4GrDtpGYEszn3xWf9y6Tqjy8o1GcVNExGSi5RXdxLmYwgpYMZIdclwq2p7KGAvQY14FEtGub5pEEZhiFiTHsi4aaPWpbKU1fHsJM7YPzFAZCvC3XISIxTbjLWWCtBGS+BmKVvH6BL1ksVjR9kuQxJS+4o2woaK6i6m4oXRwVVBliPdwhR1Psy9IcXeL+ffqcdCE4OuHACw0cXbXZhdoefFus7osnLNeLS+eQADlplbRSwPiGAHW5JCDGE+DhdjBpqQREjKLHkArIAsq9AJU1JanLuUuNADp5mlC+6e0yZkZr1T/cMX+kcuipHlNGOgn6GxD1lEkk6HGdkVbIgCNXRLY2IG+pSyIlYUx3aOCwl2F1AQ+RAiV2kwUiWbWGxoWSRhJ6UsdU2DXIQU6JCepUGiNKhp6OMCw/BTYN9ZKi2iZzJItkINU3GjghIW07PUgNXrmul5gJ6llmyOq2uhB65hBsaidUaXlcuMdnWIyS9HDUYxbPaOXpbWzpybGF0qSQ9pEEFnQkqBi1tAXmE97t7B0TszpzIoVAU9Pv5yciZsrXCPU5vC+YDaSEW8q0cQ8QDBoj4uKy2rPChMRcTJGeLMcdo8vUPbuicwroQEUj7E2YpPysPFw72Xr4zBqLWphvgchkQEzPAYAJsgQ2LdkopW4Q6oIh67y4bCI3XgBQFcXVY2LjX1fRQ0hvTWDuGXVSBWqpMILUTWhQ0RDRNF5OTXECewI+wm6Vp1fZ+bRxADFjN0gVSoqqjuPGPtRLRDPakkFl2CkoCbo5GcVpSUWsgBMcRnWdu6Nbcb6ZkaXVwWB7C9a1K8LVrGxRyljOd4Eg5xrBgS1ySug4CbYeQXN64zuqxczSh+FgPpHxjFyfMJiCAX4dRGqRKghGCRyqAQZXRMIucsJ7+WQ0xcKCxSxJH9cPSp5wTDKKckPFJPjsW6hoRslTr5kNkJ8hssh2RgLK2dyqra/YOiDplZ4KwxP80dRtA/cuwMJDEAOI5PyifohAknVz8CX0JbtuLhFUL8yoZI4wheQRaFXWwwBoxmnt5hxKk0ZuSQJBrpGRf3gNOWjmyaMvtoY+d28owDu7DvwFFsNnkeewdD+w8cjVYlYlZJ4yTTLkTSARGE1Gw0LikvSin86osSn9if9QJcbWwGQQjXgLevjCuHK4R6fVy2o7MPyEI/+85g2HcG7xcYFRYhHHBGVVnbRc8KdRIR/zqjy8o8o9VdnI8FO8r1DV6wVVTWrNQkk7Bzbnz95ZhD8qHYhBzsWXCoCvfHWcG+YvxiE3LBAmjABUDxquAFfxgqyY5i1bAoZEVgBCXYFU4MPXDyIBvDCbUt7WOcaXrILazz8ArNzqtmlvOKu8dSUkm8yyYwvXTORhNTCkmhwILB0DNnXeikwwivDAa7KNhR8SkTcFfr06CQKBm8MKuAyHjiEvMUqsTY+GzSvhCZGqvPugTQGTmV7LI41Gn8A8NglzkOmG3sqMjobG5Bna9/RHVdD0cAxDluIbIYxsMRoxk7yCyZXIw2hV0oqWiLUiYwy4Fi/CKj56rqeoVDmpDDRbLO6LJyTTuK5xVt4QX8MgXRPp0nBOTcUKASWwiInD+WMpXOGYWMnApOFQX6gRgJVvyvFPNxyqmUQr32nqmB0UvYTrrCR0uWFaVMkIc7lvqnPVukvRDG9c+CC5aP8bBUGIkA5TTEU6ZzytIwBsQAl01TzyxKzzRgRTbEAJilBwZAM3aTtaQNsQrrSp1QMz9U4s6hC4xK3HHhMSVptLQRhzop9Cz+HCAcMTEYRVk6aBTib7olbmZsLBIP1GKVjolwWNYZXVautqMw2to5VlzeiqPMyq0+6+yTmlkKwRJ8TFs6x2GaDIP2WFzpRHLysDTunsGsIjYjvhQasxTTRWMKdE5LlFNCRuXo6ieLEO7MY0Q5YfCHi8c5YuQ436xCgaWMR1oRoImMcwtqMVFBocrK2m7WkjqkPdsiSA0Oi2FD9MMYWJ2ycIehtrupbUTqTcKLzolS8BWUacxQxcZjZEVVtT10tTBUqX1AsEK49Vbc2No1DljEQph2gmlCAnFDgudhW0wXxkM/+Acac6yIm7mQpEUoQBMAcGAxycyyy7RfZ3RZuSajTFPEe/jF5S3EcJwhwkEiRWZPnLTDc1nbuZ6xchbvUCbVNwlZCBYlIbnA4pQ9a5F22J/1zCusO3naHi9pbetKJ5zgIeOH0kmCLc7xUXOrzNxK2uPHM3OrAkOUOEEbe3cCx/yiBhOzE7hvshncOqaItXoGZjGihAdEILb27mRgoxOfMOwF+tmug5M35BHREvzhtT28Q+XRsSamJ6KVCSkZpeQ32C2AAFa2wnZpY3rkFIEBa0m3gU0Pn6Q8aPxQ6plusbgkQ3TFVXT46Gkxq0vBoXMcmCVbIr07deZsXeMALh7gpMGghKQcGUIIckrRZAqPnFI/MPoBh+XocUtiDwbMhQ2s64wuK8szWkKyQnzGuSHvgQkOKMET+Y21nRvmisSF2EutS5MYxc1BGGedU4KFkEcbWN3UzMLZ1R+b5+kTStxJY3pGsaN5hfWuHoEYJBILQkwsjRAXJuTYOQgPJYHmaStHOiQkJei8zOh5qCXGbWodYeuYbQaQnl0h3SjA+Hn5yMje3L2CuaKIJmEOdBg2o6JPOschSF64pqHX0ycsVKamDQaSegZz3MImNFxNz6xCGsRlgxdmtFxRji5+RMNY8X0Hjnj5hJEhEV6zX2edvFk3IDiaaxIjKv4CLDCK28HYu7gHcilyhR8+dqaiupMIWDrIQB+pjGeQrOjk4hcD8eqkdUaXFYnR8isZpUA6zDnANsAWvpK8m5wX8wM0otZIv6dz5prbR4WIc+j90sp2GnNuqut6MaL4QVJsXDOJAgYYaITUWwwrAbqmoZ9Tjl3B6dOssWUYy42hQjEq+GLSCPwv55ioA0rAhRGyOWwem6AN8THnmBpcJ1unK3KX9OxyBp+VW8XIMbdcYwyVkZOks6HSyjYYJbgkr8I8cyW0d03CYkPzUHFZC/uFXacxG/XxC88vbhQf+BDu+7JRIhaODJcEvpvGmHNCFDbEUNlB8ja2S0GKW1AGiS3nuHFIC0ubBFMdoWPTXGn0iVfhgucSZUgMjGO1zuiycrUdxSBxzji7nDzO6Pj0nzisHFw8NQnN2PSfKAgJx8glrBfoCKcqr5rTwFIaU0NBbHOB2cHRD4ScQDR1qHTC0rLKOT10xUbpB5dNA6ZsjtmR8Y+pZ0p7CnhJhgQNUMhahIxQTp+MFoUGkMrIriAoNE7+YXjsI4JL6REqpqOTf6DAYFhFAp1rAM6ExlN/pJ7+pe3SmNUZudSScbJdCKMxIQ2DYZdpTBsK7JS47gydSGOmkuHRPyuWC79uDEqYMstecGWylNWxshxVEGcVdp82FEjdOFbrjC4rMKpQxmDVOFicTljEcbd2Ttg6eKCYIvyaaLeaUjPLMAbCI+U5lWABxJwn2nMuLU472J31FH5P1yRjEjAMeOHE1EIscWZOldSz1DlxnptnsI29G41jE/NIaIS7Mzrh4WWlOplZmCDGxVfi4oUwd+gC0Rv1OHEWRakS/YKimjuMZMpSh0Cj1qebmFpgp2mACwYLvXBXvIGwkq4wxsnpJYBLY5DFepmYWTDFR3OpQLnGkIGppnG0KoHG/ZePA9Riyw+aniBIyM6vpdzcMaYSn08gzGCWK0ceFVtSIRhC3A5HgxWHxz4mWuXgcNAIMDDzQ8aPJHtMz21dk0QU+Pe8ogalJoUOQRZLT4frjC4rk5OTWVnZUcq45PTixNSCpNTC2IRsnCYRJDFWeKSO4BInRYhG1uztJztteZaALDxC6x8YmZZVxiopGcWOLj6ElWJjb3mUnt5oTFx46owDq5CpwCstE1MKoNzHP9w3QM7m3DwCZRFav8BIUorAEIXUA9slRgQLV/dA4TH1tEJxrRJdXCbd0rmbZ1CMNoXAQOgwVVgEW+RkIWEqL98wxqaLzWDTgcHRxNCka2pdKrN0SFdcOYSMZ6wcg0IUxNmMTR+XKaRKoSpbB3crG2caE4hLPbMJAmgbOzeOSVi4moHBHJvwCxRCXr+ACEbLxUYlmVaILCYts5ShspZGn0bcHKWMZ8rYuGykDumHQ+Hg6OXs6scWnVx8WRom19Chp3fIOqMrydjYWGlpaWZmZvanklVUVFRSUpKXl1dUXMwUKRSFlhnZJemZFAuyoFtsXFxcgtKm+IrGRTTmPxqIzQRhFeoLi4oos4m8vPyCggLa5OcXSBsSVisqzsnJYSlTaS3Wy83NZWl+fj71lOlofkFWFvWlpWX0IGyzsJC16INuGRJCY2alrhYaSxuVGtMh3S40vrxTQmNm2QXa0IDG0vDEdelfmGUlaVSItKK0liB5eeIkjzqpQ0nYCkeJ9uwmDShIg1ln9DqCNZ2eWpVMT0+NT0wTYI2PT1Nel1sl64zeShkdHenpH+voHp+fX5dbIeuM3npp757o7TcKf6G/LrdC1hm9xQKa/QNGkuLh4fmadfkbZZ3Rz0Q6esZ7+sbWTektkXVGb72A5sDgqGRKv1hKjWtC1hn9TAQ0yZx6+78wU8qpHTMa29vaWltb+Pel1nVGPxMBzb4BI8nT/PznK6PIyEhKSqpao9fp477segWjkmm9aRGPzLrMC44eRgeGvoCjMjExUV1VZYhLNk5+MjBy8cuuVzDa09O9oP39/QM3IrTnZIyPjw+vJ7SicDS6er+YzAlGy8vLklKye4XX2kx82fUKRmWySEnl8mgvL19XV4/Vq4uLu59fQENDw8TE+h1sQUCzr9/Y2TP++TsXGK0oL09KzoJR6RmoL7Vewahen4XGx+fJ5YY9e/YdOmS6f/+B1ei+fftNTc327Tug1eovXrywbkoRGB0YNH4hvzkJjFasUUajoxNRtTrd01O2deu2l1566bnnnnt+FbJp06bXXntt//6Dhw8fbWxsmJ6eXscURgcHRzu6Jz7/AyHZ0cQ1yWhkZDyqVKZ4eoa98cabzz777FNPPfX0KuTJJ5+EVEzv1q07Nm58prW1ZXJyWftBdjX2pZXVZ0CCHR344uzoWmVUJtOjkZEJrq7BL774e8h77LHHHl+FPProo08//dRLL71aX99oZmbq6R0yNXOJg7XkhHKCSara29ubmpqav3zCmJuGhgbZhfn9WVHYdxKmzt7xVVN9y2Se0aS1yGhwsBqVyQxOTgFPP/3Mo4/+9pHVycMPPwymr776Bu4eskvL63oHz7V3jw9eeeeFs5uRkUlOFhWl+tJpZKQqIkIZHa3s7OzEoM7v0jLCTuPi27sm+ge/gIdLJEYT1iSjAQFKNCREa2/vvWHDhocffujB1ckDDzzw0EMPbdy4aefO3SUlJbOz0xwprEhr50TfwPxJgta+vr7w8MiMjPLExIKkpMJboomJhSkpJUlJReJsEbOLl95aTU0tU6ni0tLSZmZmhF1aRqT9JaNHxYrPW9Yyoz4+Uai/v8rR0f/Xv77/F7/4xS9/+atV6s9//l+/+c3DCoXqww8/kBImTlX/gLG1a7K3H6szPDs709bWGhAQkpCQr9GkazQZt0R1OgyzTq/PMhhyDIbs2NjcuLg8rZZFq9oELbXaTBrTT2xszuK1xEWftkR1uiylMjY/P+/8+fMSDUuEXUaHhkY7esZxIxyGz92GCrKWGbWxcUZtbZ3PnnU/fNh81659e/YcWKXu3Ln3yJETFRUVk5OT84dKPGfktm3dE/1DszW1DY8+usHC4kxaWqlanSbScAsUKI8ft7a393R1DTQ1PRkSEuPuHkz9ZUxXUglo+I6Ly2VIgYEKzDBlWNfrBdwpLG4vMhrn6ekxNTU1Lrp7EJS4RCFyYHC0u3eMw8oUZ/+FAIqsZUa7ujrRvr7e+vq62tqahob6BW1tbSXXQTpEaWxsaGioW9SgjhqjcZSjs+SuE+eJ+anZT3buMnF2dkxLy8Tg3VpGDx8+feTImS1bdu/ffwxe9+wx8/EJZytLWi5RzKe3d7iDg9fOnSYREXGHDp04cOAYNR4eoaGhmsjIuKNHrczNbel/YRUYNRjSNj77jInJoYmJqeFhIwE3vgJH0dUrGM72rvGu3jEuS4Ha+QPwBchlRjPXIKOkAkRaVVXVYWER4eEKSeVyRUSEysHBycrKBrWwOGlhcUomiyKBWGiDskpmZuY1c17O1qVLF21sbLZt26pUajBUMTGpYHpLFFN38qTD3r1HrK1djx+3cXT0dXML8vaWYx2XtFyiGFoTkxOHDlns2HEAFg8eNH/ppbfMzW0wxps3v2dhYf/8869aWjpjaBetkqlQxBKxPP/8C7kFtb2Dsx3d47h1kneC74FBo+DcRZv6xYrEaHziWmSU3YNRtVqj0wn2SdQcEhHsiomJ6fbt2954440HHnjwm9/8JlhkZFRgq6RmFEgpQkPlw8PXfoZibMw4NDS0c+fOY8cskpOLVaoUML1VSm8YQgJKhSJRqUxesnQ5hVGYPnrU8tQpB4jcvdvUxMSc2ZMn7Zl9661t2GZLSxds58IqYpCatHfvnjfeeHNwEBbHJJ8hcfmFo7kga5lRrODU1KSfX4BSmRQdnahQJHH6o6OTTE2Pb9r0LCnUz3/+83vvvff73//eT37ynzKZXq1Opw1KYxBxd/cmJIDyq39kooYDRzCAuRWjumR6vlUKPRg5qbCgixsspxERsdKKjAfnjpmMikqgjFuPiopnyn4tbi/WGA4c2N/S0sKBmt+320/WMqOYwO3bt7/66utabXpEhPCbExRaWbncf//9ZmYEeT6PP/7422+/vWfPnn/6p398663tmCJOKs0wY/hcM7Njjz32aHV11fTU5NVGxWg0dnd3hYbCaOatZfSm9TLKTOexXuB78XRBORrh4eqiosKLFy/ezj/2rmVGVSrVjh07CgqKgoNjZDJDeLiBk7dv3+Gf/OTHjo6OGzZseO211zw9PZ9++ul//ud//s53vkt6gaWhGTaVaWJiqquL8559pjPnPiGTWBKciQ+YGsPDo7FGmF4w/dtVQkoqwxA9Lyz6LDQmJg1G09Ovc3/0C5e1zGhhYeGzz250dnYlAA0JERRHT5p81113WllZnThxAiOKNSUe/bd/+383bHg8MFAVFqajWXCwOjw81scn4OWXf+/m7jM+9SHJBHku2S6ZBEcNUs+dOxceHn7qlBU508qMQltgoFJ8ciAZUy3ev8zAKYtT4aYSU3DEHoeFabk2aCb5ZcJHri6aKZWC+77lCqMyWcyXhtGEjDXI6OzsbHR0NL4eRuEPDQ3VurgEfve737/33p8+9tjjP/3pT7Gm//Iv//KDH/zgzBlnuJSaBQSocPc7duw5deokQS0WkyM1MDjaJd4sJPMdm7goj4jesOERV1dPEiwp2F1OYZT0XC43wOWRI5Y7dx60s/NycvInxTEzO+3k5Ld//1E7O8/Tp53efHObmdkpkjaY3r3b7M03tzs7B9DG2zscnpZ0+7crXiUsTJWenn77M1pXW3vTdrS9e1J8h/r8R2oWpl19wkv1hZfgie/tX6hfUGmWFTvFNw1KU0m7xLc6Lsy2C58znX8b4eJOFsr0j0qvE7yCUXbv448/ioyMdncP8/dXoH5+CkDcsmUvhvPf//3f/u///dpXvvKVu+76+quvvh0SopPaXFalm5vP7OzMwm/ZkqPH4/cNGKdm//DW29ujoiIzMwUjShQLpssp7tvE5ARJDC2fffYl4Nux48DevUcOHbI4dsz6pZfeJO/etm0v+J4542Rt7ZaeXmFubnPggPnmze/t23eUllLOd12VyFso4zSkGqm80GxBMc8hIYrs7OyPPvrodo5H33///cSEBI02qW/owsLpX6WCRUPLkDzKkJBc0C2+934Bpuy86oaWYbiPSxQ+eU8BjCCPNigF2lBjiM8pKRc+51xU1iK9g5LKvMJ6VmFW6qpJ/PoFBUkl9MXGQoe9g+fpoai0uUr8IPRSRoFMpYqxsDjr5BTo6BiAurgE29n5PPLIE//93/c/+OCGhx9+FC9/4oSDm1uo1EBSKysPNzevsbFr/FWT6OhnY2NjH3jgfjs7R70+Cz8OpsspiLi7h9jYuGNNmaLMYiC3bt1z4oStn1+UqelJZikEBCjMzW0dHHyYPXqUeMTVzS2YKJkelvR5tcIcUyJpyBPHA6Zk90L+Fx2d4O8fbWPjgUVfvIrYUvfkk0/GxcXhc+Z37zYTYqqYmJhf/vIXWn3KgPDOxKUUrqyAAhZRygRDXHaMLlWpTk5KK4pPzk9MKQwNV7t7CS//NsRnxyflZeZU2jl4Ap/40tPZvKL6gODo7PzqGOFT+0U1DX1+gZEtHWOKmETpAzfevrK0rHKQ7Re//mNt6wrx+vhstS61ud1IfWPrsKd3aHikPj27wsUtgFUiFXHX+D4TbmJ4eCgyMsrX19/fP1DUgODgULk8KixMLmlIiCwwMOTyUkH9/ALk8simpublnlvD6nDskpOTrK3tiRdXZhQFjrNnfXDoYlaUhpMFKTe3ICkrogcaACL1MpnOysoFpHQ64aY99RJzkZEJKmWCRp2ojsEEJjC7ZBN0SPCAheYCoENbWw/MMzXbtu3bunXv4cPCzVH6X7wKEMvlBN9BmzZtamtrW25nv0DBQHDxvPrqK1qtNju37CZ8vcQocMQl5Xn7yZgq1Ulw4yt+h0kWoVNr0zSGjMjouJAwtaW1c1pmWc/A+f7hC7AofQqMRRSa20adXf1TM0rD5NqM7Aq1Lu3AwWMV4ud1MJPJ6cVevjIo1+jSuAxKKtow+RjOo8ctac9W5JGGGG0q/ShUiVcwSurd39+v18eq1TqdzqDV6lGDAZ+rgtTAwCCmQUHBGo1Or4+TlkoaE6PJz89f+ZYhnUN/cHA4bGGrRIyurSxFoQ1EFmYpgMiSFZnF/gExrnnJoqioeBcPvfVZrb2zNlweF62Yv0d2uYFgQffvP4ZCZ3JyiYWFA3YaTI8cOXPgwHFIhdHLuC/0mRgaqkpNTd24caP4l1tfzJ8mryw4+mPHjr3++mvJqXlYrCUIXldhVPL1KekluGNAqanvi0/KpwbzGamIL6vq0BoyVJpkgMOt1zcPscplsuNzCmrBUaNPL61oCwpRFpe1gCPGEkeviEnKEb6uKwS1TW2jXAY4dEym9MpfyenTOLewjk0AOvTTFbb8Ckanp6cJtsLClPHxeXp9JmowCM8TnTlj9957773zzubXXnv929/+zltvbUtJKZEaSJqYmB8YGF5fX7fCaYPRnp7ugADBEcvlseByEwooUgGrtlB5TdWq41/aobrj7rD/9U3/zdvlMdFsMSHi8uoodhQLSjjr6OhHaEtqiDH29pYTW/v6Rnp6hkn3FhbaozAql2sffPABb2/v29bXkw8MDg4cOmQSrYy9CV+Pwor4ZnEh9cHmdUgfUhq+QBlrR6X44nrh807C0vkvkQrRJEuFj4QMnkeZld5BTgpFM8ynsK4YvEqboEOiT5CVkjNJ6ZmW1NNYWCR+v+oKRj/88EOSVkwFBgySUI0mkwhv69atDz74IFGhXq8/ePDg17/+dXt7b9iV2qBabVZAgMDohQvX/oM7KqemprCjPj6BnOnwcAOY3qhCSWioBudOIThYjS2kwFQ0ckJZAleaKqLifPwNd/88+I6vut59l/3m+w44mdhEKtPCI1Pl8jixQwOYYoNB09U1mCFhjCWfjrKIbhdvHWUrfn7y+Pi4jz76cH7Hbj/hUM/MzLS2tMQlrMX7oxqN5vHHH5fJ1Pg4zhPwceZeffXN+++/PyoqijBAJpMVFBSYmpr+938/gC9eOKnEgm5uvk8++bvy8orJqWkoXaJjY+OdnV2vvfaKickRYkrpnv+NKuT5+ERg3tjinj2HuXjoh8wJXkmewJdsiRrahIZqw8Nj9Srtc0cK7nii4V+frnv2cWvLtx4Ls98R7XMyPDyepYu7BT4QXKhZTiMi4n19wzMyMkgB54m4LUW6Pxobvxbvjz777LNyuRw7Kp0zshMSl3vuucfDw+MPf/hDRUVFSkpKX19fWVnZt7/9rX37jpHQSAaGSFEmU7i7u779ztaRsQtdvcLd+8U6MfOx2WGL48ePRkdj/+LDwnTAdKOKbTt1yhE0uYS2bNlDKLl9u3BP6u23d7722uZ9+44C7nvvmVAZEKBURundg1L+7fCf7jgwd9/xPx7cY3/20Cuhp+7XunxbHuoWFp4SHr60/+sqBtjHR0Y8ets6ekkkRg1x6WuTUexlQECkTGbAFEGqra3nnXfemZiY2NvbSxplZ2cXHBzs6+v7jW/cfejQSTGH0KIYmKCgSG8vjzfeenfEeKG7bymjkzOfHDx07MSJ4wqFBqZZBUxvVDGf5uZ2rq5BhCI7d5ocPGhOZmNj4/7uu7uPHrWSGGVUZOVnz/rqFPrf2zf/r31//tGxP7xu3nbytMbXKVDr9XJi8J2JUY+Gh2vCwmKX9H9dxfp6e4etM/o56xWMEoc+/PDDnp4hoaG6oKAYfCjTn/3slxs3PoMR9fPzc3JyOnv27N133/Xkk5uwKyyVFANjaXn20Ud/W1RUPDk1MzQ8skSNYxPt7R2///2Le/eaQNjNMYqGhGhIwM3MTrm7hwIrm6YGR+/pKTt82BJeqaGeynCZziUg2Skg1cojd8/pPGtHhdLnTE/I/RdU3xvR3x8uU4SEXsEol+XlsmAyL1fOFySFUU/P0Ly8PHLn2/ke/lpm9KOPPsKbOzh4BwbGkN76+UVzwo4ft/33f//35557zsfH28bG+q677vre976PfYVjGkg/MgUHa2xsnOvqapfLmYhJp6eFnMnd3RcaYEgywDeqQIMf9/WNEj0vkAkMSWVSHwpSmZYhoVp5mDoqXOXlF+voleDrH10T9uZHMT+aS/52jtLKPxgPIFh0fIXEH1EsoyKc4MokxqWeOFXiksLlrRu8vMLs7e3InSeEm6PDt80jo1fIWmaUfDAzMxND5e0d5ekZLqrc31+5cePv77zz7p/+9Gc//el//uhHP3nzze3+/qrLDQSlvYWFbWPjSrcMjUZjb2+Pl1cAYME0QNycSrgsqUThKSTkWvWhahZFh8jK5HvaNK/XaHcHhWiDQwTcnZz8T5ywx/RSJrV3dg5g1sMjzMUl0MrK1d5e+DOS06ed7Ow8AVdiNDAw+rlNm3bv2WscmxwS/1ZkaGhUuirhVfr59wsHV2JUvyYZHR8fHxoaCguTOzq6ubh4ierp5ubN1MbmrLW1A0qBWVdXoXKhzdmzrrGx8ax+zYfwJYFRDI+PTxAnW2KUE39dFSATmBY4E1dc2mCVGhKsDgzW+wcb/INig4O1oUKEoNy1y3T3bjO4VKnSiGjfeGOrqempt97afuDAcepZumPHAcrEu9LjNbgOD4/gttbW5194MTu/Vnh4ome8u1fUvrGevrHefmP/gAAu+/sF8jrPaOxaZLS7qwtTNzjQ39nZ3tnZcVnbu7s7exe99rGrq3NJg66ujsHBfhAE0+Xuj547dy4zM8Pc/Azek/CACFKiB+OEGZO8tqQ0YJZ6fDFGzt7eG8/r6Ojn7R0hxQlUSs1E2yYl3cK9IbEfHWtJba5UYusFFUJt9PDhM1hKW1sPxgOde/ceQYGV8IaAx87Oi8rjx222b9/v7S3HSIvhjfydd95+863N0pMQXT3C3zOJeeGY9Af1KOXu3rGe/rG+xbxKB+JzkbXMqEZr0Ghjdfo4rW5edfp4vSFBZ4hfqFlO1VqDSqVuamq6+ldsztC52Znk5KSHHnrw2LFTAAeg1tbugIgxMzGxOHPG5dgx6zNnnAkzbGw89u07hqs1NT3NolOnnEDk2DEbM7MzEOPmFoyDhkhLSxeaMUultbWbmdlpU9OTJ07YOTj4gB3++lqYXq0CsmfP+u7YcXDbtn1QS2AD94s5JjbFiFIIChJMqZtbkKmpaXd39/j4VE+fEUalGxcDg6MoUPb2C4AKyPZe5rUPWMcICaRD8TnIWmZ0yPhBR89ka+dYz4DwkWrx16qphpbB5vbRwdFLAyMXu/pmhoyX+obeHx77kMZdfdOiCs9T4fgqazriExI+/PDT32CkUzI4ODpz7g9vv7M9OjrSYEiEAEzUe++ZqNUZIPXEE8++9dYOENm//9jWrXtfeOH111/fsn37Abh5++0dW7fu27PnMG73nXfeO3jQfPPmXXAZFZWIwduz5whLN2165cUXX9+169B77x1iraeeev65514FO2ye9GzryrrAIleLhKZUebnBPM3SLNw7OvoWFBRcvHhRSJhGRzCTkhEV/qB+dMR42V4ODUt/02wkDBA4FlGmDZUs/axJXcuMZuVWNbcb7c56Vdb2FJW1VNX1KGKSzC1so5QJpZXtRaXNbV2TGdnCp4WpT0guuPxbrajdUx3dE9u2bY+MjDx3bpazgM/HruAKWWqcuBQSKn/ssUeJaLGC2Dlzc8HmEQvCFnkJJpOyiclJDCpWE4htbT2xpidPOmIpDxwwx75aWrqCsrt7qFQms8FZ79plJrb3hksqqcHi4rtBCuxWo5dxvH57UIbRlJSUhfuj0DY8LGJKYNp3xUugWCQuFd5CKhpXAdPOHqGw8Ic0n5FIjOpi09YgowFB0XAZHqEvr+6MVMSFhmtyC+tS0ksaWoZMDpmfPOPA7J59ZqHhaht7N40+XWR0/sHpduFhlmFvb+EX0YzM/KHR8+3dE+3CtzXmz8fs7ExQUOC+faZSDkSEd+jQKRw3YaVoyYQUCkMl3poVXLBYKdRTSSxIrAmvZ8/6QPaRI5a+vsJPoGIeQy7/qXdmdaZL2LpVSs8MIDk5efE9fHYNqylZymt+SIQaFJS5YjGll2NWgVRhqdTolspaZjQ4TJWVW3346On4pPzcglof/3Cc+BlrZ9D09guXR8XmFNRa2riw1BCf7RsQWd88uGBKKVTWdtfVN+za9Z5fQPj41KWFv2SSRLinODHu4eFHzCfZOfIb2KK8BIVlVFhlAcTVmL2b0JW7ZdPkUovtqCTsI06fAFQgb/kX5Un1NJBIlUwvKy7X/qZlLTNaWdNF6IlPr2sawIgqYhKJMgtLmxpbRxpbh8sq25vaRksqWlmNQllVO7ntQkcw2t41/tZb77zxxuuDgwPj40stinR/1NnZU2L0b1egWVJzQyr9ACF1slD28hKezZNqpEWXtyI04AohAklLS/v444+X3L5gZzGTgo3sHcesroDdPKkDRulWgGR9F+pvicwzaliLjPaPXOodujA4+kH/8MW+oQsDI5d6Bs8zS7lv+CKzvUPvD4x+wJ4vLO0ZfJ9ZlFUA19PLZ2zMyDFacgqZpXJqatLFxcvXNxoCbkLx7zAklSHGxydSKogKSfPIQpXUZmWlJR0SGWM7xRqh7OQUgGk/cOA4cYWUKom/UERIq5BCOTsHPPLIIzExMULMfSVVzPb0CS9+IuIUZqXaRSJ6kgmmXMAT48L/g8OTvQNTaN/A1MjoxPhVIq0i3lq+AVnLjCanFd60pmQUK9WJmVnZ1/ybSY4ycuiQyZYt7xE+AseNKoh4eYU7OvqLrKgIZLdv3+/jAz1RwOruHgZhwATEbm4hEn/X1f37j2/dus/a2p3g4eDBE2RmZGzkbS+++Mbbb+98+eV3du4U7kmRpUkdQj/xaLhMtum55+oaOoZHJq9OfcQbT/P50+IlANfS0hIXFxcfH59wWRITE2LjEvWxSYbYJJ0h6dMFl4XGSUlJvb29rD7f0SpEYlS7JhnN+xskOzu7qKgIJ3e1n6Pi0qWL9vYOW7ducXPzwY5C1Y2qn5/i7Fl/UngQt7R02bx516ZNr5iYnDA3t92+/cCbb24HKfGG1OF33nnPxsYTnpb0sFgBDgO5Y8dBGD1+3DYyMuHwYcvXX99KV9u27aeHTZtefuWVd44etX7ttS2Wlq4BASrWglR7ey+9Trdx46byqra+wRn8dV//p0aOPRfSfOlO0yJMOSZDQ0OxsbEdHR19fX0whwwMDFBmhn+SXi0s7+zszMrK6urqWr01XWAUL7fkfH8Z9QpGF35JIqAcGhwcGlqVIhzuycnJaz6xBqCkBZMzf9i2Y7+3t2dEBN5TvhiXVSqM2tp6mZhYREUlkddv2bIXpCDslVc2v/XWjkOHTu7aZYplpebdd/fgqSWqllfBfdvZeZ04YX/mjAsGlVWsrNxcXILhGzSdnQNPnXLCbFOPYYZp1iKcOHvW94EHHggODpmYPI9nl27Ug+NCZCPtL4xKTl9IiYSf33DaY1hE6eWs0IZdbG1t5bhRli7s5QS/xPVfV1e3elMKo2WlpRp92vD4Jz0D57/segWjcrnwJke5PNrFxd3Z2XX1evass6+vP75s8XGUTAgnkkthcGS2oqL6scd+u23bbqI6nPJNKH4ck/bee6YWFmdPnjwLYRJkkOTsHARVdnbe7767m6U+PlHe3vIlqy9WupJCW8IGF5cguKRSMr1UwjdQQqQ0pZLGNOA6AdzExERyptFR4aEn6T0X8zdHL/sPqBy6jCnaNzA+Nj5laXnGxcUZ4DCocKnX6wMCAkpKSmB3aGh4cnJgeqp3erp3kgB1oL+vrx/BiE5NTRUWFuKgWPGaPzJfU+gfuyuPjEnJKEvLLEv9kusVjMbF5SYnFwcGKvfvP3DokOmB1cn+/fvNzIQPiGVmZl26dEk6lIL1GB7FxrR3TwjvjB0ZPjc7297eduKEpZfXPCI3qlDi6SnDmkKVhNFlhgQjJ3IZQdKDR16y4srKWqy7pPKaSpQCo4vvjwo4Xr6HT17P7EL9yPCI9O5c48QHPv6yF194gfgSIjk+GEWFQlFZWUkNJra7u9PRsfDY8TLzE2WWVmWZmXkFBUL4BJ1qtbq+vj43N7e7u3v1vh4Zn5hobW1hqKlffrmC0ejoJK02k3Rk27ZtmzZtenZ18vTTT7/55psHDx46evQY/mt6egoiBwaNmE8YFc6XeOb4b3h4yMrKwcUl1MMj/GYVViBVflX9vHp5RS6puYXq7R119KgNqc6Se/iiNRVM5tCVlo5F+Prp2Q+Pm5+xsbGuqqqS4iKMXFBQkFyOIfebmppoa6t/+JHe73z3T9/57h9++auPm5oGJyaE21cYURrA6I36ekloj/VdA3IFoxHCX7WnEnK9/vrrkPfU6uR3v/vdSy+9hB3dunXbyy+/3Nk10NMvvH2lt3/p3ezJyQmdzmBhYWNpefbLqKdP2zs7u5P3LMGF3RTuOmFKr9pl5tjrxsbGJ554wsXFhRV7enogtba2FncPf7h+punp+RUVzSUl9TU1bVWlJWqFMiIssrykSBYWEhOjrqio4FSt3tevMbmCUZnwd21JBHkvvPACx1T4Otgq5NFHH924ceOrr77R1dm9efO7hOqjY+eXu49NON/d3bXoub7PULu6Okmdl2R411WM/fDw4NC1dHCwf2Zm+v33z0/PTFOYmZ2WPuDLngqm9Kqf7CWBLQhra2uLiorCiOK1saPEmiwS0/peeE1PT66oKKqpLjOoo5/ba/KYqe3v9ju+uO3kli27S0qK8PU0Gx29sbuka0auYDQ4WC2Xx1lbu2EaN2zYIH0f7Lry0EMPPf74Y2+++Q6AYoAJ+YUfmeb7v4YIKe7nIiTR1dXVubk5+fl5q9fcnNz84uyiiqzCa2h2QVlmXmm6pDlFaU2t9RPjE4Se2DjpLw3FRH6pEEqCo8FgwIh2XinU1NTU6HQ6onmtQvHYoYNBdS25M8XWLdu3649seHN7e3Nzalo6vv7v9oPWVzBKthEWpj91yvHBB4Vvgj2wOrn//vsffvihZ57ZZGFxiiN+m7yEm2COtIOoT6HQx8TEazSJFKKjP1VmFQpDdLSOqUoVR4FKrS7R2srB9rk0rydb3FdUj9+1uD/e5LYzsbWjaWJyAi6FW1FXZk4LAqPk6TCKBcWgSnc9KWMdKRCnRkZGJsbGbT1q9laGem7uk7I/unvO3nuy5zev2r+kV8XmFlQax84Rz89393cmVzBKmhwUpLaycv/Vr/7nf/7n17/+9W9Wo//zP7/55S9/9dBDj6ampn3wwfwHxL5wgVEiuZiYZL0+OyBAQZBNOih9XgKNi8vX6bJ1uqz4+Hzxzbf6+PgCjSYjITHfzz/Y6ccjdnfMXVcd7piz/69WTVz0pQ8uknP3i7/X91z16NOCrw8PD4dLwtm4uLiGhoby8vK0tDQwJcEnhVKFhT9qeuDh5pCIC8d93v+F17nvH2r/4TOWG/LTCzMycprbiUKu8VDV34Ncwai1taO1tZONjZOp6fF9+w7t32+2OjXds8fEzs6RpP5Gc8/PTjDnarVGLhde3bh7tykBjJ9flK9vJFNv73AXl4Bjx6yPHrWibGXlunfvEReXQOHdQdo0Vzcf23t6be+Yu67a3zHn+KuOBx/9tZe317lzs9Kt+6tDUkIOKWeys7PDgoLp3r17tVptYGDgqVOnaACs3t7eMl//jSYHv1bp9fbosyeM95n1/PDpwh/df/y3TVVNCQmJpeUNvQPTQ5/lU6e3rVzBqPQNMfEzYuJN5FUL7XFnAHr75J7YUZVKHRysioiI9/QMMzGxOHRI+PDSu+/uNjM79fzzr73zzk7QpN7ZOYDC7t1m2DKVOvmsg4f1t3oxk0uIvFoFU3pfZ2lVwbObnqtr7O3uE98l2zUhfLRpkRqnPj5y7IytrU1RUVFTUxNXsq2traWlpZWVlY+PD0cPRs3MzEwOHHjh+RfuOLP7rtjt98nv+6Hf977q+vOf7n5OF62mwfDoOfH56GvkZGtermB0Pte4Kbl2Gv/FCYwqlSoMJxH26dNOe/YcPn3a2dT0lPig/qnNm3eZm9tR2L//uIWFA5GAjY07jSOj46ytnM/c2bcaRrGjdj/ptrQ9+eZbb/YPjg0OCzlTR/cEprR/0EhgKunk9MWgoLDf//7FmJgYAAXT6OhomUwml8s1Gg2un3yIsq+fX6C/v4+Pr1dQiFdAgHdAgJd/QHhkVEFBfmZmRn//YE/fBP1f8zHqtS1XMDpftyZkenoqKipafPQuxk98Ei84WEO0HSz89dz8Xy9JTzQThdNGKoeFa09ZOJz8aj/8LSHyaiUePXFny8uvv1hVXcnmjMZhiJTSJsJTSJLUaBydnJywsbHBcLa3t9fX1xOMSl/EFz5oWVdHDaQSAyA9nV3dHZ3dHV3dnd09nd2dHR0EssBNw1HjRFePcBd2QPzW4+0kw0bj2MTMufHpG9XZ0VX8eLZmGZ2dnYmOVlhbu0u/kaJeXgs/1jONXJhdWMQ0IFhx6MDpI//YD4LW11PaHPyXqoqaEnImghywGRR/cLo6JMXPTExMKJVKoKytrYXLVQpGlwSrpKRkenqa/nv7jdLT/rfV7Xzj2BjRXr5Bm6OKyFVHrVKzVfJ8vWaATHD8Oq8aXrOMEhy3trZ4ePg4OLg6OrqvUl1cPY4fOWXxnML+xRTbF5NWUJsXkyw3xofYJA6N9C/8kg46AIQpFe6SLjJ10kxUVFRmZiZRaeGqBTrj4+NJsAYHB6WvtXABsImr7x58YTKKfZ/Oiw4cCH9pOubZadXz6IyoUnl5fXZE8Wq51r+vt39la7pmGcWwgen4uPBS4yW/JK2kwmdACWZ7h6e6hqe6V9ahqa7JcxzeT60m3Aimrkf4xO0ShhgKjl6tVhN6Rt6IKBSKsLCwxsZGeqDPoct/OHWbeHwGMX3uYnG445zhN3OaH85p752L/c+/qH46p/6pUF5B1T+cS72/Wba3Kr9gfGp6vrtryZplVBKO4GcowpOf8xuShLmFp/IoLF6KrR0YGEhPT09NTU1btdA4KSmpurqaFFDqhz6Jd+n/NsnxZ2dnlWq9267n/xr/2znQ1P28xfWHiv3f6vT40Zz253Mx983pfzAX+z1BDd+bU35/XhXfnYv9yZByW3FK0sT0NR47XixrnNHPX2AIRyw8VErUKM5KAmQAWlVVRQFeEULMhfIKMjk5WVlZWVBQgB2d7+vyX6Rc/QjL5ywzMzNcSL99/KkYq91/1T80p/rJJ5H3Jh359ojvjyptvz+n/hnUVru8kma9I9N6W67DtiH1llH9uyPad0cN25sDHxuLeLZSH9zfP/h36uu/QAFNyZRCkhSYjo4OX7p0KSUlhRwI7GjDlFizoqKCxYQlY2PGqamxyUlBpYf2JYFLGIVsotgFRukQR09EQY4vWGup9ouQixcv2tranrK0G8tT/jHyvjnFj/+kuDfW9FsFp78bsesbczE49O+8sKH8/7l77qt3z/34v/5a0zw+YJzsGZoamPwowM36YvC32oM3V/6d+/ovRKBGfPBZMHVob//Y5NT5wMCgF198sbOzEyjJ8fHgwcHBuHIARVpbWysrq/DpVcKkZkGYqa+vT0hIwOjO9y4Km5CeBiSF+gIZ5fpheBsef9pl25NzuvvnIn84p/zpdMAPkw//R7/7PXPKn/xV/p1ivTY+dSgxsT0rq7upriGHYCcxoaW1XelvWXl2Q0Vawvi6r/9CBG6wpsJz+D1j/UOzBcV1zzzzrE6nw45CJA2kNIj8iUTq/Ln+M5Ztd949863vTN/9jZmQ0K7+/saWlpauri6DwUBez1pLfL0oxv6hmb7BmZHRqUmoX6VMrrbtVZu7hrAvuPvaxrbI42/9JfrncxH3zEX8aC76x3Pqn8wpfzwX8cO/hH67NSe4oraqoaEsNz1ui9nRx3efemq7/bv7HY7tfKnX+/4ajffAwNC6r//CRDCoQ6PDo9OFxdUbNz4LbQ0NDYPCn86MYkf9/Px8fX3b2tqMxr6YmCYbmzE7+1EbG2NR0eBAb0tzffXQQF9KcrJer4fmJYwSBgwNDZZX1JaUN6A1tauTmuqqurrKtraKVWhNZ6dxfPy6Rpp9MU6dLwq0+HPYj+bCvzcX/oNFes9fQ75VGuudml2UpDdsPLj/dHqepi/vRIXZa2FWTzzzu7mwb3d6P1ORkzN+pZdYIuuMfrbCOYbUc+dmvb29X3jhBawj2X1PTw9TglHg6+/v7+7urawsamkpbmkp6e2qVEXLNh80f2WHzaEjTnbWtnJ5eGZmJuZqvkcRi6GhIaVSHRwcERISJZerZTJFSEhkaGjUVRrJIqnA1F8W7bFvX/FLvy984YWVtej559Nffz0nKWnyel+YFgZjnM73OfrnkHvmwr47J78HNOdk3xcKYd+fC/5mjtIpLiFjj/nRN+KiYaz2zyEeM/eZd//unRO/abH5TUWybmzyOptY44xibzi7NyrnYGp6tToxPjEsOPbryAcffIDthEvp0afu7m4Kvb29UjknJycjI6Mwv8DVzfVR81NnUtNNkj3f8LP52ZPvxKhiMIDFxcULdhRHTE1QUHhycrFOl+XrGyGXx8bF5V1+7DAvNjY3Pj6fMlOFIkmq12ozNemlqQdN5v7xHzjn19evfEVlbm48f57NSfHJ1UI9oxqbvpDuvPfPQd/FLk66f+sPgd/5S/B3pz2+PRf63bnAb6SEWkaFxzxquu+Z1sikD10DLz7gff77pt0/f8X8e722/1Wt8Rsavuoe3pWylhkFUE5/UlIiOUfijYhGq4mPi0+KT15ZE+OS4+MSGuqFu+vzm1xeSHqSk5PLy8uvfhQfTNPS0uLi4hQy2W+OHSy8MPvBXF/Y7It2g4894/aiUqmtrxP+NHQxo3V1tf7+YeDo4OCzdeteb+9wMJXegh0QILyd6siRMyEhal/fyKNHrWxs3KOET70lyuNy4nfsXC2j//Zvxx955M2dOzH5wh9WXH78YLGOjxFHDr+7Y6/lCz+bk/9oTv6toLf+T/7hr7dZ3+328lfn5N+ZC7jL4Hs8wDfscZODd9d57Bh9wnL8Xov+HzxXeu8TJt+b87q70/5/KvPyxqdWMqVrnFGFQhkVpVco4tXq5JiYJIUibrEqlQlKZXx0dJxKlaBSJVJA9ZpMR08H895fmBrvOWz8/gpqZrzn2NCP3BOOGQcm2db8Vq8l2BvxVeuZpaWlQMmVA6lkSzh6ptRwFakUCvOTp36scCr6a1nSh4f9Lv7IafLejcH3+vkHpadnLM7rJUa9vITvVAUHxxw/bmNubid+UW3/sWPWmzfvev31LTt3Htyzx8zS0sXExOLtt3dSUCiSQ7TpsW+9M/cPq2L0z//0T+VubvvNj9vZu41PfSTdo1iiY5Mfurr77dx7qDna5k8+d82F/Ydmx9fC3vmqavvX9O99bS70W3MBd3qf2WVi4fLs61vv8Lb8RpHJL5Lv/3HMf/6r7Lf3vffrrlM/roqPNv7d+nrcx+Bgf2houF6fHR2dhC2xt/fG36FqdYZanU59ZKTwSXqDITdQeGukCoeIZ4zVFQTIfc3+9NVtc3fsXFF3zN2xf+4O07gntZHx58+fn9/wtYQsGUxdXV1hFBePqcZqYj7Dw8Obm5thVKvVhgQE7j9k9lWD4+bxrTYT9zpN/MC0455funwvMkpRUVaxxNfX19e5uvoyfizlgQPHTU1P7t9/fPduU6Zvvrl9924zYN21y/TkybMWFg7W1u6nTzvJ5XF+yiTd719eoHBl/cs//EP26dNv79nj6ek/Of1BT7/whv8lOjF1MSBI9urb28r9j/zZ+865kG/kmf7fhN1fS9zztarjX58L+o+5wG+mmHw7cOv3Qt/9D9ct33I5+EP3Pd9w332Xy65vRe375qjTjytifIZGV/rUB7K2GR0IDg5TqVJCQjTbtu13cvL38Ah1cQnw9AxzcvLDtOzcaXLypAPsYoe2bdsnPoqfrFNlu4c4m378f96bu2PPirp77g6CO7PEJx/81aOysPDZc+cJ265W4TdT49jWrdveeOON6upq8vqgIOGl+rjvd999l7QJRiMjI+3t7I7sP/gVe7Nvd5zeWHf/MyU/+K/UH/37mV/I5dFVFZXZ2dlLfL2Dg0eo+IksR0f/AOEFlPMvA/T0lPmKLxj08Ylwdg6U3ryCch16RMRqnt64GMSV9H//72P33bfr6FGjcXRsTPhB62qlmsvv4BELy40/EIj0u/uPXnf/1ffuOb9v/MlbmM75fmMu6M654K/Phdw1F3znXMDX5wLvngtC7xI07K4Wi++XZ2etfIt0LTM6NDTo7x8cESF8ZdnR0XfLlj14QMkP7t175PnnX9uz5zDlw4fP2Np64CsPHjSnpSoy/WyAzcFP/nXXVVAuURhFPZu356UUPf3M88NjH4qvrl6qfUPnE5LzX37lFZL6/Px87ChEnjhxws7OztbWFmoxqGFhYbt27zq0b9+mbVs2OJ7YaLvl2TOvPH36jSdMtsnlEakpKWRy8zsmMtrY2HD6tENgoMbPTxkofPBNerWloOKsKiBAUKks1fv5KZxkBs2vH7gCxBVV/95703/8I2HMcjkTwtLpC5/kOW77i+u/zvl8fc73zk/VZ0X1+/9Gbf+jJCZgdHxK4H15WcuMDg8P+vgEhIRoOVWHD1sSt50+7WxhYX/qlCOu8NChk2fOOJNSUMCmYkTt7LyCg9WRoclW3hb7P/nn6zKKHpi740jW4y/87hU7O4fZcxcHh0av1pHR8Z7egZdffvnQoUNlZWVYTZInnU5nMBjw+DCKKW1oaKgXH35ua2xsr6prrW5urWltq2lpFx+GTklNZcUFO8quGY3G8PDIkydtrazOLqilpeMZS0emiysXqaO5jfPZ519Ivf/+1AcfXFmT778/7qGHCuPjJ671nrkrZXRk6v1s530fnLrjLy7//Benr6xWXf959MS/FARaCr7+7/MevsSou7sP5gQrAnzAukilj5hJL9tf+EqO8Hy+LDDBwsNs75/+ERu5hMirFUbf0f7QxcprUniTrWANrlZSpunpKQg8fPhwQUEBRCICes3NTU1N0rPMAqDLCG3S09OzsrIwn+KeCQKj+N/ubtKvLkl7ero6OrsbW3obW/rIyphdWLSgPd2dXcNDTWNjTUbjdbWVZH5qSghWridjk1Ot1RWZjruzHbbkOG5brZ7dXuC8RXfs9ZqiovHLT3VdU9Ysowihkqenj62tt6triItL8CrV20X5nuXbmy/csfWTO7Z+vJJu++SOdy7dcTBpw0T/ucUAXS34ygsXLqSlpRFWgiZWc5VC48JCzFn8uXPn5vu6LJI1XSxQ2z840dM/2Tc4Qflvl/ktXVeGh8meRqYuDI7N3qCeG5mYYUfm+1lG1jKj4+PCi5YCAoK9vPxw+qtUX+9ge3cbB8N+pzgTp9iV9GzsAUftobySrInx67/2YnJyEiMql8tx9NJd2FVKQgLJu29RUdHKl4Ek8x/i+WKegGaLNyPzay8va5lR6VcQ/Ozk5ASIrFamJmamZmdGL86MXLi+Gi/SnE3Nb3JFwTKBWkpKCr579ZKRkQHWJSUlC/HoCsIZ7x0Qvr4nvZN/bchaZvQ2FC6B6RsXknqM6ArJ9RIBUExp37Xe6vNllHVG15rAZb/4xyToaqG+vWWd0bUp0p+PXv0K2C+jrDO6BgUuBz/90z9h9kst64yuTYFL4Y9Jeq/xV9RfrJDIT01NzQfaq5N1RteszH9MYsVPmH7OIt1pKigoyMjIyFy1rDP6JZAx8Q9Eb1QmJsaHRib7BqdR8XvCNy83cD9/RZmYmEhOTlapYxOSsuITMxc0Ni5dH5u6pHJB1xm93QVE2tpaq6oqq0WpqakW/lp0FUIztLisrqi0rrSsVvwj05uQKjbd3t7GMOYHdLMiGVGlKiYnvzo9qyIje14zcyqT00sSU4oyc6oWKhfrOqO3tWB4SktLVTG6hKT0hMR0pnEJKXEJmBxxdkGT0hPFGmG6oGI903hBM4Q2ycJ0YenCKtJaC0vF+jRhdamHpDRVjLaqsnI1P3StIBKjMWpNelZZSnppasa8pmWWJaYUxiflC587u1y5WNcZva0FL69Wa9o6jQPi16/7hy929Ex1988Mj304ZPywf+Si8IXsYeFT2ejAyCVmmVJmqfC1bFGHjB/0Dp7vG3q/u//cwMjFgVGaXRg00uH7g6OXaEC9OJ1lKX1K/SyszqabWge0Wu2k+CHJm5Z1RtemEAjqdIam1qH27knhJdHdkw0tQ/XNg1V1PeXVnU1tI529MxDmFxjp4ORdWdPtHxSdnV9TWdsdqYzv6ptlla6+mYLiBq0hIzO3ytHFNyW9RGtIT0orqmnoj1Im0EmYXBuflJeVW33W2Sc9qxxcQsPVrNjWJWxR3OhUXWOvwRBLSDs/rJuSdUbXpixidEpitLF1uKVjDChdPQI1+nRzCxu1Li2/uCE1sxQTK48yqPVpQObtFw6+WMrO3mlbe/doVUJLuzElo5TwDijtHb1kETqYgE7ah0fqm9uNgJtbWAe1Ht6h0E9vnwmjMTBass7o2pFrMooGBEXb2LlBWIhMnZpZhu/GO1eAl1cIyIZHGQ6ZWdDYPygKu+vhHYJifeMSc1k3RpsSGKIA1qAQJYYzLinXzTNYWkpjfXw2jNY1DXzKaM8Co7ciHhUYLV1glAGkZQrGG0YZkji7lNR1Rm9ruSajtY39ZVUdpRVtlMem/kgcibFkii3ML6rHXlIurWynfVFZs7RWWVU7Tp8CxrWgpJEVxRigkRraUAOR9c1DLC0sbSosbaZDCVBx9VvH6PCwRqOra+pjW/VNg42tI1xXlKvreytqujDhJeWtNQ19XBUsau0cZ3gNLcPrjN7WcjWjmLrm9lFgIiRlNjuvmilnGihhlFmmLOKUc47LqzqYYopyC+ogm2AUDnoH35dsZFf/fMAK0xTmK/tmpEB2QW+lHRUZbesa6+iZZkNYa+Lm7LwaLgn2K0yuCY/SRynj07LKGpqHElMKDPHZRB3rjN7WIjHaeCWjbd0TmTmVAcHRqRllJDop6cWc2uAwVVZu1RlrJ2CNS8qL0aVinMiKmOrjsgJDldn5tcfMrWITc/uGLyxG8LoKo7W3jlG1RtfSMUpC1jt4Pim1SIiJk/NbO8YwqwnJBQyeHXF09klMLSDmlgLldUZva4FR7VJGhzltzm7+J087lFS0Wtu5EpsSmKo0KYUlTWER2vBIAyeb4BJrSlKF+QRrQ0KOZCxvQm85o/iBNiHqmGaEAcEKsj32i0RQG5vh4y9Xa9O4tBTqJMy/q3tgTkHtOqO3tVyL0SFOJ4k8eT3RG2hCLT5RF5uJH/cNiMCtY5y0hoyaht6zTt6c46q63qLSZnwr3pweFvO3GhUYbbj1jNIzHr+mvo9Cc9soe9HSIUQplLH9RKVtXeOVNV3rvv52F5FR/RJGOW3d/efwlcwSmHKmpVv3lCmIi97vH7nI0o7eaaZSjViYpTFTaijQA1PsmYTvQlTaM3COwoKKjPYYDIZbyejlm6/i+KeaWkfInKTImFlJhb0T87x1Rm9rmWe0ZXAxo2TluHuU2b6hC/AXER3rFxDJLLEpJhbPrtalsQr80YylKCtqDenVdb0aQ0ZsQk5FTWdIWAyml2CA+JXUnuCvpd1Y29BP/HpFXn8LGR0ZjlFr6wg/mofJiuCytnGgsWW4pr63sra7qrabeLSucaCtc4JhN7aMEKQ2tY2uM3pbi8Co9gpGG1tHquv7CNcgKTRcDZrEbUSfQIlbt7FzKyhpIKkn88DcDoxcJK8vLG1SqpNI6uMS86CzrKodZOmHaJV1iQgjo+PItwgeWJFYkIDhakb1+lvGKETWNQ7CX2VNd3BoTHlVR01dL2UvH9lpS0cGmZ5Znp1bTcQSG59NPLPO6G0tEqMNV9pRpmTEIbKYxNRCB0dvgtHB0Usj4x8D3MnT9lAYIlOHhWtoFqVKIMgrq+pgUX5RgzxKSKdYRBSbnVft4h5QVNbs6hFEppKeXR4YrMDEBoUqj5pbifcmhS2iuN3PglHsZVPrqFafXlbZTlQKo4VFjXEJuVW1PZbWzlw/ickFoTJ1akbJOqO3tVyL0WGm0IYRHR77qG/4AjaPuI1gjkJWXhXuMj4pPymtiGbYThIs3CUhIKhhLOuaBnRxmWlZ5bkFtUp1MjaMmvSsctHFZ9c3D+JkWRdGF0LGz4hRfH1FdZetvXt8Uh42lQEApbtncHFZi52DB0keEcsZKyeSv3VGb2u52tdjR8GooLiR5BeSSiraqMQc4hNhlBo4I+gkL6ZQWtFGzEebCuEBFCFfJgAghCUrgul+ie/e6Z4BkqepviHh3j69kUtJdC4wWvPZ+HpMZmZOJSNnwMSjGFSuHMClsqyiHVgx9sC6zuhtLddklEJyWnFSamFVfa+Xryw5vRiLSBCJKSIMxSjiyv0CIznTnj5hxKn4Tfx4Vl616eGTBAbk/gv8rUZvMaMx2pq6HhhltLj75jZyo+HKmi4CErJ74SZU85CQ5jcJhpYC0+swOjZmFN8Qf5MyO3ujOrvw0cF1Qa4Zj2IsMZCG+BzsHw6RlJxFxKYJKQXmFrbYHvy7LjZrYOQSaUd+cSOzhvgsfHdVXU9jqxAqLPC3Gr3ldrRR3AVGxRQEhZ2SEvzWYQIP6oW7YJ3j0q0o2qzE6Jj4PnnplUM3IcmiJCSw+mo1Li6+tLSU7c6P4O9elsuZlDFJ/oFRRHI29u6k7eTj0i/y3r7hcFle3ZmTX9M7+D7mlsCgpKI1O68G/97ZOyP1s3qlPbFBQ8vALWRUCo5BEP/u5hmUkJxPua5pUEj15NpoVWJ2fg3GlTwvMaUQU7oSo+PjYwqFKipKL70oPjo6VqmMV6kSKFyuWayx4qL52ZiYJG/vkH379h85ctTM7PBq9PDhIwcPHrKwOF1dXfM3PvK9ZuSajBJTNuIEW4YJMTE/nHLxMXshysTw0AbbwxSVnh+V7uGDhXTbn2aoOCtUAq50916qlHIvepAApfOM7MqM7LLY2LhbxmjbKMOQ+ueKIlbp6J7EgpLqEZsGhiis7dxwC4QxhC4MYFlG6XFgQHifvE6XpVSmqFSpGk1mdHSiXB4rvlI+XaPJuPx6+XTaMBsaqpVaorGxeWfOOL733s5tq5Z33313//79+/YdzMjI/PDDD+fHsUgYkvhXireXgNH8+D4DoXPNtRilDEawNSj8Dcn7MdpUeZSekE4Rk1TbNCBlQkR7JMX1LUNxibmccuneJ/6UkJRYFia0hsyWDiPBAOk/HDMlhMgpqBWfzZthE1Rq9GnmJ23tHT21Wt3fGIYtYZRAJSu3is6T00u4NsT4JCMgOFqlSVGok1SaZPD18QvHP6zEqPg+eZlSmRwZmaBQJEdExB84cMzU9KRCkRQaqvH3j/bykvn4yMPDDW5uwcHBMQcPmlOGYxRkYfSVV1554oknfrc6efTRR1977VUTEzPWiIqKOnfuijcIEwAMDAzU19c1NNQ3NjbcJsp4uru7IHV+lLdaxq7FKHRGKuJ9/ISbmiFhMVl5VSKjhtzCegdHbxJhbOqQ8QNyJlsHD6UmGePEUlynk4tfaWU78WuUMh5Mbe3d8a2pGSWJKQWxibn2jl4VNUKQkJRa1COm9tjUwBDlaSsnGFWpYm4Vo1xj7AhcchWRyZHUt7Qb8Qy4dYZHbMrFVlHdyW4Wl7fWr5AzSYwGBIRERMRBHlMzs9Pbtu17/vnXrKxc9+8/DpFbtuzeunXv7t1m+/cfO3Dg+KlTjjKZHkMrvFVelXrihN3zzz+3ekYfe+yxF198Yc+eAwSmmzY919rWsXDuMSe9vb0EHjJZ1G2m0TJZRGPjqj7RdBOyHKPYy4joWK0hXbrdPTh6iQwJSxkQrIjRpRaVtXDuiQRc3ALAUSmaJYJUXGekIk6pTlZpU0irHZ19hD9mSs4HUCA+edohLassPas8ShHfJcYMMBoUqoJRB0dPhVJgVMDsZuUKRnukZ0qEeIOtCIl885Bwl1d8XpsaVByA8PP9SowODQ36+QWFhupCQrTAd+jQSYjcufPg9u37N2/edeaMM7AePWr59ts49H0HDphbWrqEhGjw+Gh0dBKLnnzydxs2bPjt6uSRRx556qmntm/fxSX77LPPVdf39Q0KFy57Nj09XVZWGhGhTk0tjY/Pu6YmJhYkJORTiIvLS0oqSkwspLC4wWehiYlFanUSCeLMzEpfvLxpuRajw4RoutjMGE0KjlsKQFFOLTkTBrW6vje/qB4jimVKz66gvSImMS4xr6quF5qxTHhSIj/yFZbi0zGrcEmBDAzKiQpitCnStugciHHHNnaukVGaoZHZgUEhsLk5UiVGVSrh9/pGQmoxnsbvt3aM1Tb0VdX1wC5GVKjpHIdaUnuGsVLOJDHq7e0vfaEiKEjt5xft4hIUGKhydw/19pb7+yvQ4GA1aGJig4JipA+sSCqXx5maWjzyyMMPrVoeeOAB3P2bb7771FNPazSa6ZlzHd3j6NDwyKVLF+Pj42UypcGQo9GkEwEvUa02IyIiliCEpaApk+kw/DTW67OYxsbmMiVoZhFTtTptyeo3rYQ05JHJycnT05/JLbN5RpuXxqNYTQyMFMZJKY54y0bImbBAkiliKhZmRVsl2Cc8OCyKj6FQmKYTOqSlBHrvogSLbaEswiT7BkTIIjRqTXz/0GyX+FH+/gHjsPBNnxuD9TKjmurablK9+qahssoOIpbY+BzBv1e2BwUrA4IU0cqE/KIGAoDU9FKijsqa7pUYHR4ecnX18vdXLnxIJThYwxReUQpSWYRVKdVILVEYxfvfd9/P/luQX61GkV/+8hfPPPN8dnbuRx99xP4wDA4Kjiw4RPab3/waOwptImFLFUYDAqLhEiiJlbdt23vq1NmoqPigIJWnZ5ira5CHRyjg2tt7spTGS1a/aYXR6OjYz5ZRzVJGITKvqD5alYAJdPcKKaloU2lScOLFZa3efuHF5S1Y04io2NrGPhf3AGwkLcmTcgvrzI6cik0U7qri30sr2+APIiUcl1OR8pm6pn6dPnZ4ZBJAOSOdIqm9/WMDgwKkq4T1U0breuqahN+ZMKVh4RpUikQZdk5ejbev7IyVY2xCDoOHYGBdllFkamoyJERmbm6PT19Bra3d0CWVtraeGNfHHnvq8ceffuKJZ1ajtNyw4Yl3391ZW1vLpqUxjI0Ze/pGn9n4fGZmekxMnFabqVKlXK16ffaJE/YQSbpmYmK+f//R119/19LSmSDk8OEzxCf79h3Zu/fwkSOWhw5Z6HTX7uQmNCYmLTJSn5SURDQiDfjWisRo/VWM2ti5ySJ1ZMQBQdG4bM4uDh0KnV39/AIiSZCFB+06x6CT1B6Cbe09CoobsvNrWJ0wAF/fM3AOn56QnL8aTIkfdHrD5KRw7wkjKr3cFFLFl5oDq5EYYGj4U14FFce/WKicnZ3RG+IxjTAKoFxUbh5BhBMNzcNsgjiYRB5kQ2VqeaReq093dQ+8zrt04EP8cGBSbGwcrvaGJC4unhUzMjLT029AU1PTKisrx8c/vYfPxYeJ2r59m4nJQYVCD6NKZfLVij2zt/fy9g4PC9MCJSb8xAlb0KSABXV09GXpnj1mu3YdsrFxh9Elq9+0khpGROg+Z0YphMhi/AIjUzJKyLuxqYBIlCn96QWV+rgskMUyYVYNCTmEmNJrHfDy9MAiAgMaY6tIpAgYJBaXUxpU1/fAqHR/VLCGI8L7Tfv6jdJLzTt7UIFaybgCMcjSYFik9rIMnzs3m5iYcPTYiSbh9yTBjmIj4xJz8fg19b1VtT2lFW0p6SWAC5fZudWgnJBccP1n80iopZ8ob1TOnTt34cIFKGeXjMZRSRGuRZgTFZla0gAl+Ri78sNqk5OTLS0tmzdvDgiQL8coilXDnJ8+7YQpjYpKxBFHRSVQKS3Cvzs5+Xl5ySgolMkxiuTYiLRrqDxNG5VCg8U9r6AwKpdrlzDKuZT2brGyX+LPw8L06qXMX/Nni8uMDixmlJyJfKKypotZQMTOEaE2txvbusZhDgMJf5gl2heVNmN0yYRYBdSk1cuqOghPoYRF+PEFFpfTjp7p6rpune6K35mgbx7WQWAdE991KmB6GVmhIFDbJyxCR4znMrMKH/3tb+0dnBpbhuoaB6Tf64W7Tpd/r29sGWluMxKb4vqlB5yZZXodRm9agDspKZlQISwsQiYTlEJEhMLV1dPW1t7e/qytrYODg5NMFokutAkNlatUaoz34hvj8Pr+++/X1dUGBkbiW0mMrla4ZAoxMTGpFKBnYXq1qqKSQjTxJ7OUp67Sk9kKj3gdDZasspwqlSkymRqPAWTSaMfHx3EFGoJeQXSSGgyxarWWXWOqx9vFJzBdWIqSIxYXF1/9IzCMqq9iFCIXHk2CM3DE3WM7SdVHxj8Bu76h91EyoSHjhxCM1SQGldrTg3h/fv6HKKlyZb0mowsiwcoUqyIY1wEjrr+nfww654NXEdnx6Y8trZ0sLE40NglPOXFFkdSjwn51TgBrTUMf+9LSPsZohUKHUJD0M2GUnamvrw8KkiUnF8XF5UqalFSoUCQeOXJ87969W7duffzxJ+655wc2Nq4ZGRWL28hkMVlZWQunXJKpqamiokLsKBRiHW9ORfsqFHSy5FOZyjvmjt8xd0ycLtbDG1t9DaEpC2sto/NdRUcnhYaqEhMTpQEDaHNzU3Aw1jpVo0lWqwU1GDKCgxUmJmb79h189dXXn3zy6d///lW1OkmnS5UaoJSDgsIrKyuWWNNrMsoJLixtxg929s2AJqkP6YWllRNWMzhMVVLRihMnHk3LKvfwDs0pqMV1MpVWXyBv9boyo4tlnlfRviJQO3T5g5TGsemq6roNv91w5Kh5z4Bw15Oe+4YvkMwRJXd0T8FriEzt6OyblVtVj6FtGiCrY9js7BWMrsu63J4yz+i6rMvtK3fc8f8DlWCKTSDIFw0AAAAASUVORK5CYII= + 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 From ad575da2bcd8132ccdba2588ec7787297b9b8d52 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 12 Apr 2024 09:35:18 +0200 Subject: [PATCH 033/141] ADD: logo proposal --- README.md | 12 +++++++++--- assets/logo/logo_400_400.png | Bin 0 -> 13147 bytes assets/logo/logo_text_600_643.png | Bin 0 -> 32605 bytes assets/logo/logomaker.xcf | Bin 0 -> 125150 bytes assets/logo/logomaker_justlogo.xcf | Bin 0 -> 74299 bytes assets/logo/logotests.3dm | Bin 0 -> 798682 bytes assets/logo/raw2.png | Bin 0 -> 12709 bytes deps/eigen | 2 +- src/gh/diffCheck/diffCheck.egg-info/PKG-INFO | 18 ++++++++++++++++++ .../diffCheck/diffCheck.egg-info/SOURCES.txt | 13 +++++++++++++ .../diffCheck.egg-info/dependency_links.txt | 1 + .../diffCheck.egg-info/top_level.txt | 1 + .../__pycache__/__init__.cpython-38.pyc | Bin 0 -> 132 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 163 bytes .../__pycache__/df_geometries.cpython-39.pyc | Bin 0 -> 11092 bytes .../df_joint_detector.cpython-39.pyc | Bin 0 -> 3472 bytes .../df_transformations.cpython-39.pyc | Bin 0 -> 3433 bytes .../__pycache__/df_util.cpython-39.pyc | Bin 0 -> 3239 bytes .../__pycache__/geometries.cpython-38.pyc | Bin 0 -> 3939 bytes .../__pycache__/geometries.cpython-39.pyc | Bin 0 -> 4125 bytes .../diffCheck/__pycache__/test.cpython-39.pyc | Bin 0 -> 259 bytes .../dist/diffCheck-0.0.3-py3-none-any.whl | Bin 0 -> 9938 bytes src/gh/diffCheck/dist/diffCheck-0.0.3.tar.gz | Bin 0 -> 8460 bytes 23 files changed, 43 insertions(+), 4 deletions(-) create mode 100644 assets/logo/logo_400_400.png create mode 100644 assets/logo/logo_text_600_643.png create mode 100644 assets/logo/logomaker.xcf create mode 100644 assets/logo/logomaker_justlogo.xcf create mode 100644 assets/logo/logotests.3dm create mode 100644 assets/logo/raw2.png create mode 100644 src/gh/diffCheck/diffCheck.egg-info/PKG-INFO create mode 100644 src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt create mode 100644 src/gh/diffCheck/diffCheck.egg-info/dependency_links.txt create mode 100644 src/gh/diffCheck/diffCheck.egg-info/top_level.txt create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/__init__.cpython-38.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/__init__.cpython-39.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/df_geometries.cpython-39.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/df_joint_detector.cpython-39.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/df_transformations.cpython-39.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/df_util.cpython-39.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/geometries.cpython-38.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/geometries.cpython-39.pyc create mode 100644 src/gh/diffCheck/diffCheck/__pycache__/test.cpython-39.pyc create mode 100644 src/gh/diffCheck/dist/diffCheck-0.0.3-py3-none-any.whl create mode 100644 src/gh/diffCheck/dist/diffCheck-0.0.3.tar.gz diff --git a/README.md b/README.md index dbae83cc..1e17f87e 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,15 @@ -# diffCheck -

+

+ +

+

-Temporary repository for diffCheck + ## Roadmap diff --git a/assets/logo/logo_400_400.png b/assets/logo/logo_400_400.png new file mode 100644 index 0000000000000000000000000000000000000000..55410e5c2e2aaaa849170b82c808ec7cbb24619f GIT binary patch literal 13147 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

(bJ;&zT#$nC4q;)KYLhd7*UztZA|& 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 R!$0BgNPBn`{`RBr{{eMc>zM!m literal 0 HcmV?d00001 diff --git a/assets/logo/logomaker_justlogo.xcf b/assets/logo/logomaker_justlogo.xcf new file mode 100644 index 0000000000000000000000000000000000000000..4eec8810de7af2ef1216794aa51623804fd51cc5 GIT binary patch literal 74299 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

6URO23mHp6$# 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 literal 0 HcmV?d00001 diff --git a/assets/logo/logotests.3dm b/assets/logo/logotests.3dm new file mode 100644 index 0000000000000000000000000000000000000000..24a0c052c08906c72dd7e2f481c8e22739b929d4 GIT binary patch literal 798682 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%0AU76GPXt4#(h zlUUODf>;OKE?7NAMH$oynjnb;q*K!BcWICZg!vi&<&QXDSF2xpAwBw*R3ZU!s}sFZ zCYeO=l13r{ZCafq%`zD0bSxl4v}tt?Gs+~Fh%)IV6418QX^$-PmZZtS0y0EBR;O8` zOiGEVB^vwY(g}-iBCrhlZyW>EV|7+I%A}H*RwDXGK$_JV)hvU)8OH!|tCKKMCWA!q zpG_hG{j@rPk!3PTnp`X(L-fH;kp#*^VrOz8S{=<6`wh4`uu$`b#V* zk$`cudI-)kc_d9<7LXyv#p-!5%78YX#QYKo;L+;QD9V7gfJ9^8z@OFGP$*MKVquBs z9|2=;byg9}6qPg>2Li_3>XaswK^sLRf+qs>-0JKjlmR{30Z#obkOQwtSEyv zDo8ZiHsovdKVXzW8xC`H3D9$^o#`keB-WPbEs+4-vs#w39U*CgSwM!+b*m*i%Aj8% z60s&AK=-WnCZkL>i8Uk|^%}Nh^{*?IsVQlUb_$!a`VSMzRF{Y{MmvRlSnVuk8T8F) z3$PEX{kkYqOCrYFC{x&z)gqc@FmA@N4!_l8x+WK?Pcf-TaDD63eHr_gTVs&wC6Pil z3V|g^3p$_?j32hdWR7}3lgdb>UmI!Jo?dsXPe?*Bkq;cAmqnn`Vi14;-a7Fq2GWp+ zIuNFiNKk1L$qb+o$TP|!5A`5SE>Q*2CYBjMfZ7Jeg!O&FgR9f_#^5k*v{LB#QVSliI!-9;U(qin4;|Dr^lmh+a_`sI1;8KCK z&~@s&$}{Rm9{9on3=1lPN(-H!UQkZ_z!3Vwda%I4f{CEgLY9=L`spn21eu{fSPWqi zMNnxWPar`3NEKuS-cSz~JD8LRDlK$^dOM1O-2rH4HN()`5zN??2K|SnGQF&cV zB0;5vz5|Uwo1u-PKk#QIj70i1X<;+88};)lv~ko^Qer8+ECQ7lb^`>cA2LCIAOqA> zS|TQFf=Ub9qy4F$41r!jW~isE!~lr|l@_)~`%^#80eb;&s0WMDauNwDE$kQwP(Oo# zzR<5?fr`Z@L8XNa(~i{-PM|N)8}tW@T;pO|rG-BL0@P1CKzA_KsHd_-<6>E*g+BlS z)Q>1YR?tP%gT=6M5v0=k$$X#@xN(8L9ra+5T+c|PUy~Mo1!x3*7y$MH-9kM=VhxEZ zkk(&j0FA&S_|YHe7V4=gv5rI)NDKc21h9|XXMp~|_E1kXiS;ECR9g5rqn`sEkCjIq z&{5P=U1Eqt6-Wy|2L!Mme4USaV8f`Vro;vk2`VjorO{u4jz^`V4(K}SsU@+lL={L2 ze+dMzAKX@edN9_gr?$j~5(z3Td@lX2di*zJPI)zw*Ns_;3{_g#4-la9>^W!~V@&;N zBCkV1q=QNe-%bCm_tkTxHO7YWYAUar>2)AbY2m+t0DW9Mhev}aj&pN)-2y~9sI-^^ zjPn4L}`gPeDDcB({@CP-!ujsPhSr9!4FoVbs%F zVwgk~NQ?Od2+(C9c*rm6!CZrS+DdFMk)YCo4rl}(my5CSlZbjcNDP;#0%A@!4qs0(~WN$f09 z1=3=k1R8Zb-iTx!KRNBfi0|-zLZv#(|8R{7z zaiBzkN?S!{00HVTY2bM-0W<;+CxX9)uS7lL zB#xJ;0%>c=44@HsY!B){pHR;S5+_JhfwVPc2G9sR&<6b>UlZl^BqNc2P1;&A4m1Lf zf`RV9ccVX(C617&0%=2J2G9u93CN0iI7ME+XC%_ENn2aSfdKV*6X*~7GgV%H2qGO+ z+Bz~F2v83af&Ku%*GCekA)&Xh<{Y3s`jAV58a0{Y`G5%tWHI9nn?rEMTHfB^Nt2aGX&&>VUF35ax1X;-8@ zcTXyYh;HmA@coRGhL8^}ndGHkpreVIXc4MqEy&^|qYdEpk+t4?(zvPMLm;I2N<`bZ zMwmpR8K`B=XyQvl-9WO(enG}f;mnRZ?p|rnDs#|E6L&ow$1P@NextA7{OjK7HAiMwype=TGmw{o*%Z& z5b_49^;q?Rc4BNoEo;m(yJp)A(@G+s`oaP}1M)y$0P&53TGm~{`j>4pOeaZ!YCTqc zppF__P|F(g%&yrs!}O8}sJ|d{>Mu5(&_(D1#)5WgrjIf^PFbYI2W*>R21yK5U#g-H zXy2%lGV0P(gho)y8uQGq**3$Bk_brP3nTbW$irxx7?1eo3zlVFRw3JFm`M@>39QGe z4`z0umSx;3WZMigOG2P(U+~}P2mLth!fYJWva(pbz_uA?k<>u79;-f>*@ap*-VVr2 zw#_iBOatmKe4VFR*Qfs1wL}f-j%Z2efaLg^Zfog<2ML z@d4Xrm|YSB)ff7h$6ynfGXV4r4Be^jU$v|;&+M9QGt420fNDKveL(wWcA=IvYuA{@ zwi#kw1XMR9U@pa60owqOfBGzUs{2P+^%bK-oOk>*& z@nQf-5Tn}7DVaS;U_OUEa6N_g&BlP`5VEW>&Fq?OGxU>0Ky_0G`oQ+(rArnV1Ih$x z1hp*FtwOfVFpnezeqHZUn%_4^iXox78r10-C9tL_AQAe2@!&X^`3JSEB##%^HbZ|& z4WwV-1{U-I?V}$6_Q6aZYFT#)>tD9bFs~#9svBCcu0eb7QvmbXWI-RZ=hO_ zSsx%9({WHXAE|AsakkB{pdaiPWsP}e*KC_%VMzp3*XLMc!e7Hz0pc46wXC~@^)K6ISVWQn)q1S@z{1b0gp~RTQl{YAg8{u%ZYU^bOB>QKZ&t01GTIfjWLaFGb|=Ef$F9* z^a1S~by7w>J`2|bwJg)ELblDYxFiG;xVFby8~z%;3P61@n=jlHa=hw2K5#8Or(oPF zWZMi&NJ1ci^;q@6%r4Zjj9Z0ln_)>w2vj%JVZ9GO1ses#Hx6o9cM0oXw#~4VBn7JV zSoOioF4VHtt-EvBHp9{~8JMxd$ir7BcXsL<1D&|%z!*R$jCNtB4{BLiBwk?K49iGr zpt>m$eL(w0S;(lVU8rS27ay=~h5?cosBUNkzpx3+836hQ%v&m`Wz~E&&bAqrl>|Vw z9Cwr!3Oq z1Gdeuf+Pl>cF$RY&z8^!v`@Y<23W_L^+PQy$>IgJ&9I`R20m^2Aos%ZZAGQ+Qv#0` z3KzHs#kvCeU>pZC|DcwYMdAgv&9IWB2CAEK(Fe4TegH5I7y~n%RLg=sK49AnD@$VF zzBbw0=C4*)=yoP>AB=e$ehNTYnAxUU)?LE-mu)kwB1wUJ^*)>}onPGjypd%elABbm zmNg-XmBh9g2FYBYx*-|&;_%a0#{f7E)KPb;`&TV%%rm=Y+YEyx5m2qitPju!vvE+% znzd_8W7`ZJG80JPhD|@2fORd_bO4S6?t`s>Wv%k9(uK?b61W*Vk4!-Om_GsN1Macn z>jTSz{+~cqNeujW!seZCwN5E`0Hwc7gD=2X&_Cdw+pG_2SxNSfpqiuxavZr?70&}O z4p>(LFb?pOd|rt(f?Ag8uNzjEg#VAd_kgdWdftaO2}$UN-XWp)B1KwqH#cmGMWr_@qKK&E0wM}XM?t!R6crRuMA|#g-hGzM$!-Yh_wNnwZ$6*7 zr_Jn{IdkT;-Mb4U@Bwn12cUk;T>!`cTR6#pasYY#snq}06H?$D#TMuf=nH5IyDgk# zP!l_(3$#9x4IFFLv9+KCd=M?8$#jvRm0m)B4a~dZxMmfo#@;cRP&tu&Tn@J&%b+dmt zjSpc$=Oly5Yp>5K&bk>k7a}0*PRTDqgw9C@mDj0Wdmig%*g^_{>K|%KOCH8*yI;UJ zcupr#3shdKz$L=E8MYKUpn4rQ8Jy;BmDiz)g8U{Y< z)D9}IkfjK$n_+9A2CCO_k^#1Gnm1M66a|n%*3GbuU3rN*=~2`})DHKd8LI zmLjljhHZr!s9wiS2B$eo z7iwT?WPmN4<_ncKMFFIcbu;WBc|ZdHP*z?tueU4$B__A9483BSPFN(GfyEmza@Nrqj8 z0Lb~dp|cIuUk3u zSvSLYDF7099XA*sL)W!(&W2q}=j z>$u6_G(M=jOuL1wn_*8O1QPg%)_WzRs36(`keYTNub;#Hmvu9INJxPMUdK%ar}07M zW!f!d-3)sPA&|g7sHQu*3Gc5 z6adXXLisHQu*3EE$6aWdlj++cA`2~4-Ew_+$Gki=4f#x6S zeI{Q*O^Kil&?oJF;nWT)uXzpEfORt*D3m|~|I`l|P`_%6l>CCcyp~(Yx)}}G*3EFR5CU)Bx9i<{3ElNk zM_zuna*dvPZOO|nXzvf`3r^#M$}40k0_$e@gir(3mnuL8)DJlTumxmr>XRxj=u-mL z&G1Pf2C6S)s3Upkj~K53kRhF*lW(fLpic={H^U)93{hYL3~b@#7b>rir3kE>;c%e_sxQQdmOPvfa$I1TQSww!dDU_?&AJ(m z5CWij9VZzeM*;PM4!jN|NwQcs!>6Pa7_nk_nVV~h>ubxbACdWHWgYbaaXtq?JXFw0 z29+1|DFN$dI8um#>dQA`B@btmI0FDc2K0x5NGPE4D#f==juHwWfiIM3C>f|9YkUCP z!AS-`g{G00>C}c#3n5U|B}Vd4KhCA>zUd@`$}22)1fzu-NT4nr$w2+E2W1G6xRVT$ zZ2)W3WApE4AdxC$z-TCS#9 zH^cEl03`6mL~)XV^Ff@A0VqQbf70=nypDyoOxDeCf|LPGexFI202xp}t;AfD1ijN7^=Qxzz(Wk}CHO;yi z&JY4%tyS3uj686~Gq!%W+y~M{>Gw-sq#(v?_Q?>5JGFz#D`Y7G>t;ApsDbY`_+x0c zuID_ZPu0|Obt_`Xfchf^0kB1=pwpbC@`64kVBHK~5n|xrbPIm}Wa)9wmtD`j)a1)T zdQ-`(B3M)qKpC9Y4=S&p!~K_aGkjG@fsdYj?Ugq9HT~`9#|((s8D+?T`XPti7EbM; z@(N3ez`7aE5^CUb|9;zN?xB6nBoAX$89@Nr0kSxa)haLOQv%k_aJCQweW{eeX{=Ux zQ>q_jtefE+$pfBv>EMnM!`kcIGwG6taoWDW2$QtaSgrC3S&G2A86L}e^{SR2FCjDs z;)qC-J*$M+{5&f-)y#tc_Xwh6W)r+mu#_N#h0)k?5CRb5x^QZQa4aZ-e9|HxjT_Rtr!46u-e2%B!6yW( z3f2_F;0%WtBnW!Q9WIFLRTC^NSVxe97s_xglw*>sA&5m_v>^CVmO&8ZFl=2xbarg2 zQI4{Vf+)w~TxP-Qg0%%vj*!!jxw|_%G(NJ zVN_qRfgsA+_9$;Jh)JrEU}Hg)!!EEr%I_C!D%ec0xgg3>1{(*f?Wks4qo&zly?*CCD>E2yCC#{9r6gG{9(bNf&&Df z6a+u6jedy!IZ$wjU_U{W;kx+*QTC|d5r=~@E>Rj9s6mH(^iA*}4gei&hE5Jg zK$>L|{Xe*yT43;vy&L%}qZ?Hu=6yxwJg>CIEG zx79Tn+4^F*76|%lbg-6)p+?~9&0wp?pV<3t^M+^kWJ^4$MLZW&^w$a>7wCLV%Ez0u zHQ}mo@5#+qpC1_hgQrODq1W3#a?*nfS#asRmFA|KW#&s)^hF&XU=EZ&?@eS*x)G@;$~b9jywCo60fG=tlh#yi4&P`q;CoYLB*M7P4HF20i2wm zLR`V0zORvAu84KZQzf_yxT{N+H-0W*xylqNN@*dt>H12Tl4zKU`QQq=-8@Frn z=%xwKC2{rHZw*~AOaX>{_tf_G? z)yCJ!Yc&0u2g`Z1d80i>+6*5Wb$?9c)+nPK`Q4tr*YnfPqE@*0gG({UXSjdf>oF*2 zNd8Cn-WP-GBQzwFA6RU|k_jI#>Atl7igUAndHT{1xsOTSwzK(%8Cr~%1Yp>AJ>wG+ ze39$(ebME?tRw1FIM?*$7X~I|tm^x-@|7$@TeR(vKi|eHm7i=896Pei_~F^^Nql{6 zZtayfGM%h6d2jO-N6Vl4wQ|3)--fgrIzF`JjgZnsmfUD?xlo5ALst*HQ9@Fqi|u_n zZ{ql^i$}IwGk;^yvg_Ad#%$}Neg1y46El0wxQITu$S;Z2^;Nk`7I{3%Px7nLRwj80 z!M{(3_Pi%J-$hnBuW_Y#9f|9sVto?m{T{BXOBkuW-wR>Fg|0?<0FGrnJMTaFVe8_08{1gcH(T}%Z*Bc5_SBAF9M4wy_N?YM0Cfz?6xZp`pbc+JoBSwk^02he!dG&6!8m%+ zM_sjn*9NT1b7WxRr(K^~mzsE_Fn;s?ihWw&2~%R;eCVT?h@5SV5NV&j&qyN_Is;&7 z)fsfjD>tgn%ho%i4NCc;$!TKM^h~on&3j%2uh%Df8!HG2eRIF=t|Ptr_ZT0-0Zr=Z z$1^O5NalHs;Y9+e@w{v%ZB1@Oy2tJfdGXplk6yXTtcZCBJQq$kU9kP-!=5pV`gL79 z=(NY}6^>0zkDD{@uOlNHH_>~T>F;F9gXb-fo^|qI_P8%)Y73RA&E|FRGbcFA@O6`gaRu>= z#`kA2MwQyKNWP0lm7tJd6rDJeN$i`MVefWh-=^Gx%Ew?P3$8F=JPU_N}kd( zW*X|r6cZ9NsBXV?sfkAlW5)-(?lCO)=0pC)_l6gH#8fKZT;}!rj1Xyq!2EHV&)=W$ zRWs{7u_UI+Y2xoUuIuvNud*pNfoYbfRnOD5oi^s}gvE>Q^@(nJ-{rBog!H_~r5{!{ z((t^mH>7{%f8%){o1WL^rCh(9n7h`~uhZlPAFkTq;cIKPZI_Q%`JpEyF(BCVw4SEt zWirz%WE&cHVq$FPBlmhMZz&MhUbdw9WE*PE*-7SZ$xF25Bc7PX=JSvszvrEqa-obi z<7B?L{Hy22b`jm}TX6fAaivY=Y+{is!8p&x=V-JW@>XSB}P| z3`>+cwKp0bx8k*2hQ}d|0;CNB^T)~a@-L{D&w4YlMQoayCRR<)E@73Y(LHSZj4-1= zCrs#EMHl7gZSB+m;j#L|jr@82IyFIB+c>a={^MIcwn$JXIJVsF&fInY580GBFF@|@XI ze`rfR?ytn%WA7=WW6tX!<2&ZOnbH&Cc@yL?$mU`2KEun*5NRtft$Cgn92^`JV(ep^ zRgD{=*}cp@*V*SoyN6=l>;H4)r+2&pjugg((c@-mSq5f^IbQbJn271EVqX0&%7ZZP z8;4?$e?>oId7smYRhNqd_YeC_qnT+|)!dv1h2DT%*|t1$wMk2B#hTXVJzu|mm3^Wa z=e>FF*G=Mm$697@s+YMqbzCyVR;eTQH8xYv(Qw9s3d``CJNr}S#ge(Y?Y^X&8D z55uD3X6B6Yde`>y-Y0GLQr8!}7e0B`doreQT(SI7-nO0ldh_or7?;r(?F}FFgtwii zSlpElqP@}g_V=Qq|7ZKx_dk%QEoL1$Yk2!u-`6qUk16CqI;h+J7^KgQx@d%dB}|X$ zTKC(SZ_@uBQ+LI&m<9J8GxGBmKb+!dkRaL|J$C6$>+QCZHh|raqXXZ1%ktWb7iT!L zu(357Om5%hh5J_ORytyH<;Mzs)mU%(#J)2<`xMY?DahP<2+h_b8H)=^?GAl>5re;;!QT1{44v{ z*{4pGDqUiwr{~JDF|7xl@wCZZ?!tnv&U&_)FR49hzNA(pF@T$w5p_!*?Rub;p3_`K z_mCSkFN!y`8q?1hO?Jsmo4a^4;r{i763f5U>^G_GqsVJTO2vilnd)sVZDJoSFpoc# zcp``P)R@YiwV7*q7PYGtotk*0FxE{hyVJ15v}f;^FSE%SUd(g=|@2+SX+ zRrI=M#g=I_F^QR`iB;1x&GNMBdGT)@H$3myt~XohqP#w_Wiy2IJgs(4W7BSU-h_`H zJN>`)ye&Q2ja+o>d(Yax9Sc)yDkH!Z6eGG}H5z%5Bl52UdEAzc9)>YGQ@B zGjfacBe?~8m(JrM!9m8!QLn|1|EYbyxLjP}=BvFUM0fk`Vf(G^vY%*>oQ^7C&z<(j-T@Y483I$z8#k{H0H%=r^V zmrWj5N$>Jxkte@>r;3g_FP)6*+1cy=$yIYJ@p& zjEw1@6t59CSRPHfi=X7eJ=k=%d$3{Yf`heS+=C4Y3J&t$gH62t_~)AaF)jPNXP*z( zN_(}aaoHR5!0X<|CCkOF$aKWJwc1?o%{MB>-6(X)yM6L}@2fj1#YKF0(EHHNSG_G7 zSB>kr`8RLx(y#x&-NWv#zyAa~f)+AlV9erU1EP0+b-%GMZSdZ@x=5GEbtrn5w_e?) zGoqp^tr=T)T;b!<>jssM?z^m9bX0V0<6M~+QAdRYDVX)q^tV`Uh3tmxe(Kl4N1y)f z=#)Q#tWjaxJ2z%O@=0;sS1Iz-@$YMT{Q}+B^c|E{uXTD}$QQma{nYTAZy&E#LQnrh zqrbW>FQ{)Vc5m?fauIsgo#_jYey@n0R_Aj){kuu#^LY^y{445LKJTqdYw9l+jz?%b zQ?+8v-kr%tm4CE{EtmLP@1~FM@H8xQ{=s~|?XsTiIQV134>z1RW{oQRGonahz?!Vx zhW}hTuRce+el7pcC3T;fzWHugTpxKNp+kl&-X`)y!sXL5*Ef+T67JIZoO{^U;tKn; z&pT&``&0C7*CcO}r!lnm!s5Ur{9n&DZ#w?=q;Xo7O{jeD?>eYeO=I_@$ zwRgYvQdI8mJZB5!{3vJhLmoCWUz6*nmRDMso>ttL$8+i{ZJzg}JoD54%`k6fdH(0L z^tfj7T+m(adHdS`a$a-uuyKPk#r17*as2>k6ZTS49|=FY;iR56Z-b9r{666YW;uL^Y|R`n~xs%JiL2*vN?~< zY`%COk{Q5{=)7UhdGDE?H&%KXJ#U9RZ8t3AYwNqq({^{c=e4?bd7S3vVT~iR#toNt zc;x47NuEH2=XIQPem>^BM49tqWX_98O*~QD0`5 z)Aij4toN21c9kERoF-OH&os-^s^|Fz4lq1S^*rB!-~FD~Vt!R08f9B>eZ5t&jg$Ue z&l@{($j5J%nCIDh-`T9IbG&QKc|VzR9-G;34r5G!Fd9FZRMMRDxZ2!^6_-5Q+E02J zJnt@FZSvf9X7v}RYIYBETY1`_{e|cK?I-v@+0o($t!ss#Xv}f%y*A7WG1nnKHFI9x z>gQMS%PKm|3Q$eWG)>Mf!E{>nyo6WF86I{lW=M6P=pFw;v{#pqo|j~`IVPgtum7&+ zan5_V)n~rTy?1#k?Rn^{KVRMBncE~s&b34KSvv(TK}0eGyr##^H0QiHGmU*-KUrB} zwb?|*dU#%Y+4tP7bDsI%nY;_jUQ4>qv(0n%Rj7Slgy;S3XO1=(`xgj*?B73X_CZgV%79avplVO9`|{Xzw|Z!Bg55ZWQNZT zkEG|#Ymy;O|9HmfX30EnafrXcuBPH2xIB%iDQAtwpG%FW1IDiO7*GD)@OgNzvdN@A zJG-|!;p%zS%vTOAGd-`7nO^@(nYiV0-Z*;pG_N+VVqEp_GXrYSK0X>rVH!{;FKum3_Z>6Qs>> z5iL*Xc;nP1Z>s_8+Qp4APF?OKURtiVA4DS`l@e4BZ7Bs?i+uhE%Qc#w9>@Zw)vsA4HuS%xif{iSeOmQceND9g z`JE@%chaFu%QmeM9=o~6$WItItt-;LSykHVC4V?qIGM-N3sd8<$^K`0a#ZPvn7lJR zIhT09YjAm)b&qrPs{@A=Dz@A8WQJzxV$P8#etc_C^9$K^cdtQa@!=0Wc@X%qXM63ms|@9lSwaWb=X_b|_p5@$cf z$;|EIk;0g{Y^^EUeQO&=R3Y`INXQD&jxIV%4WQHc@ zevubrn%`zi>z=1A7-D!{!qF^-=V=$O7@ikDcdL;fKWkhYy-@nIZIgN4KbkAY8T-Tc zJln!!`^P=)^TZr~I5?=+cb-$UV5b)bm2*>G+^@^8ZqKE*H~WrG0=cm3!|G4>f#kA_NTA6SBPal{bJ8%9qk8M_cq)X3H|~1qv}a$?i5q3Bp7qcyesk!$9_oLYC10o+WzLl^ zEE%)DP}xFyQCYS1kUQn+rT4*O@AB2Hc&hOvUYC!umDB8=XJ6skz1F^}#a!7k%et5#hu zlBv(dA(rRSv@|tM%r3Ca9F$r9p80OowCZ{B#pn3v#Gh*#9u^r?z`sg0Juk^B^~7V% z(*3)h#}l2;9$fs=q@_EpRq6-kDmCK6tM8X=tm)h|h`9{lcD_xHn3lT^6xDg6gH`HK zS&?C`d{pLxn=&6*Bxs-frk+3_A5IXX~R_Jk2(kHl3)0NeH}HL zm?l+C%{0p=ns0TsE}oD!-$TUxp>}?>u^Q!^7ym**W6qO9mM&yv(4So?qD zdDn9FU*ANYomsrP;K9ykPImw!IprJkqB`V0#aVNn+x{?j#*!1P?~=(y4Op80?O8R0s_JG^`_24L7ft@G`TZ`Y z)9Re3hs^E?C4Jc=>mk&4^f3M{9sf&|@f4dLw5B2Qk43)NTz|38h%CuGFZvG7QbSGJ znh0T!>wC6;Q83q9&yV{?JX~{$&suGE|6}Re4%5%Ndfso%PfcpEIETK|^gO2FdAX&> z!SmY7{|xVP&kNRqf{IHs-dAy3ysPKg|8EK6XL3HMUWZLAU+gH>yFOlb(%1( zd(yE5D-DmKC(S$CC%Gr(dg+l(|E?!Va~qI*_4Ds6zA)KZJsxNrvVHcAT^X7q( zT{Mm_Sjq6D_Tr+*k#N46DJn3HCs}s1Iiu-$irSsF)#LKE91pgZM`|*jd z9P=1&+P(U{HOi%*-fV4)*z+E~g0S__+?P+~@2mUSZ@rcBO5y4a4%F|ZH#6T#*+JgG z$hT7Be;F^=z3TPI{|xR@PYRO%WrR!nhlOX&8lE9bmXL6H|9IB$@N_|;q3Of2X3dfz zW5x)1`))|)3>iW)goj7S8+d~=MMT^qZ|2Pw91*c!+VkM7(=QtDcRgh`uDo$~zgFs| z+siENf8RLMseD|)3tPSCY7I*Af-L*XMC`9Ju)j>i?%?)6aM}N;Z2t?1{m)!(i(UKl z`(Cz+aR+|d?Ctl}81Kaa)#9c}SJ+y9nzz}24o_a*xHT_y@A=&K4;Z=^v~-s@^u`}; zU-ZLDQT^AiJGF5_7OhkHhw6XzWmvr_LQ`tnpb7>k@!fS;MtQZU&Oe|`>(dS8zEWG;=r>B|dMDZN`Hv2edCRBANAKl%qM*-O zi2QQ;*;?KYcY8)EUnV=aJn7eW*IcM@ao6z@dZ{+qUadMYzg|n;n%!Lfnzcpz1jFZD z{(^G8itO^m&=Q(`T(iGD-2Rs~`#6H7!u!v>UPOCsXoTnKhgx|u7 zmvKu6H(BTZpv7cgF~bOv#;qNsh0X%i<8>)%9b0U@MibMt=11+U4=gjya?>Hu$i|*g8zQ^(V`ltA;nL<~i$e`;sL8OFQ*q?An@# zyPLOeiW?v0=qxX7$BXRG%6b-_w_d*FaF=^tt_K%(OX7KUZ?nJP-o6ij=XE~3?{(a| zStqZ+j*(YjC#EJIDU7W%&8nw$=$y{*u32;CFI)mhFSydmgET_q0h~7Hy5wg&P;k2S zp-~V5XmXmEFShrW-g>1q%hRmqnV*n|&*ag4q8wjjA317L63^4ttZShk9bUa`GSB-* zFHtb&y4c+w48ne6*1mE@MGus`5p&00oElHJ)96ysqUebF+Q8!P8h{VY;Mn?LCa&F+?~S%zTEMJQydi% zq>=)~R&9~M8Q9&}Et!5X*ONys+`Lym(XC^)BTEbF?KWney7~1Q`slB!^ttDg0{Zw@ zI+x8=rG|cC^~rKyzj@tLwqK#)b#qtKKMVihn`d_4^h9==)h%89I=WSB8oeQ$&~|E) z`CP9s%XoQb{E-)WLpiRbeOX(z(f4)M^yA7e-Rznp5M z@iQ<%i)=g9pByA*5oQU#2Nq`LU$vc9#%*})*Rl)KH+XIT(%qkLFI%JZjkjv!dtlqA z_!+B0-sL6zi3rSr5Exfm=g&)W_L(o+yIosl+M6x$hX3ngP4W-VgR6}*X|n~J5rmAJ zSrWK?i0IeETQvTdo%iI$B5fXhrh{(JBR$KQ)_z;LytloT15O)$a0c3_(lbpOt@7f& zNndm;OaWmV-`TfEhfHduQ(|b7>H5@?`-V2qE$L08Sm_;)+)VoFqd?Kd6x8}2l)a}} z(vyf`hrIc}49K2FoAkf=-8~yKJ!tq1^C&#anAYNU4e1w<+E7B;0k%=4XPPwHj>*sL z2uN*c2TE+$hSHOUX>Dr7*pCBJ8zQWW^AKM&$QLkn(gk;I3Ts@_1FGB3rhFYDKY%!>W!(pzFFAAnr~<; zOPfvcZB_@QHtao=)M*r;Hl)?Qf3R!P7Y#{CK==)9;+MFe;Wx~q^ekgq>$dgy$~0!1 zembS6Hng8szV?u$4-W`sz}iNYp0={I$?} zl^?MC8%pZ$UCygc(&*+5B5h5l{z=dAM9+Zm8*0Jc1luH&-ZYA(&GMPg2Ik(ATF~?D zJSAVO-Zu|_70`Z@!Q5}!wV@Ij%`&F7%Bwqm9+29wSFy+0dm5!Djb*EV_ZzOw z?AlQJHRjm?)7p&;gOc7y6TJgs6u7(mCN}ZYuY3;_wARb84bN;?#a_RFfb zX9lEgoV4j}o=VXcOn2vevvSUo#rjsY`nUQX95+X45w?3UKGl z`GvM&T5COcc=v$RhLTbP`;LH`vW#hM!_q_N15z8FZmcnP0nmoKYubXNH`7|KlV>{z zq&Ae48bF(5BeH1}jtbg9-&3UmQX9^UADg>pXrrz&)t$BW+E;bv2DCODm7xtaG)I*iKhFKW@xmH^(UnUBW9=#joOT?d(OPa=sQKj4Vs1RD1+;cN%z<{Q?WjdZ z({^8cpZQXm1I?|&2JQRjyX*^S?Wlp1cI=sMT5IpufAhD1)Q(FbE;Lf=nUB`Vkz?A7 z=DuWp_hHaSlLJya+Qn`=H!akB@@Re9O&b=F+NH*J)WTJ}rRV-S5|G-lN7@&Qsur|w zPqSyLGle!O&!$BIsU0P!ec*R)TB!Nt(SADD?)iY!j<(|g6SPxpM=c&UZCCr@=_Sh# zX{om~U)!N&trOZZAhlzU^lRyVa7(oj?W@iR%-441d+lPH)sD7PwPU`v@sFMJ15!I4 z%2HDF%nr($#B1ItbX}`_oql81fYi>^D#`882TbigJ#^^x*;(3HD=sx(=k3vm*1u&B zNbQ_%!MWMaRl9jJe+bM`#p#w@Z*y$)U3n^`*^0(`YjbR5{(3W?Jyweyqb~_a+d16^ z>Z6SO^i9_pA*fO0YXPYp=Q$p5VN`L`&ee8byfe}9vFrbQZ|-zs#cgb)c508+GOl{Z z@vkNSxpq#sCfs_UI;wCM(OUmj+wrd^|G9R2T!DK9^h`G`Tu&Y{SF876K>8j1jVm%} z=hg$&6`EzcHrq=b4@m8Jm~1~_rgrMc?=}x=ea1wr2uSUC9Lr-^r=H0*iQ8DJjjl4L zgu+~a;yEkZry zgqXmj@XrrBc|CT^bdsSiuSuiklSg%6(yRHTU({vNWA@eyxQ61W#r>qc;i&`~N>%W7 zimQ83(yRHbqwbIb*8;ks*g*DykV;VrG?c0!Y1Dl3sDmcy)qK(yC^p6M@x6d?JvNYi z?@pzt1R6?JkThyOc~qAqy_!$@pqD3p@6@BNn~e4`>ge8Yn>ReOCtKo4|Jwrwf4l!O z#;8puZ8o(MR({if&7bKOHFV$yPQsiDfpaw|W9IdoU1t$Vm;hFkgU=Q{oQKWhxO zcv598;Z4#0d1ILM_^7;_vbQVu^{DT7Pc>j%NL9dXP+qa{(W%orwDYa`twi{$MYVNK z=4$?*`-k3mzEd@QK-4bpxye<1ukLtvNSntySoCT>>69VWq^jZ&CimUll{Ml0rH{C4N!Iw4XH*F3clTSdICpT(7>AUWEe2h~={jIS^ zwH_;Pl&@0dIlX`M1P%SDW7h9}y!Cn>e>#!n>^(}D;7_Y=sag4EJw89(ttXV2PVHEe zam=uT_Qq)1^Xn+7MQ>~_^dk6X7`H){3qpkED$|ewizl~r2zfw**@XbtQF%CCfd};R zhA7RvWiK)RCva8S>^!(8cr$_61k|Zc@hk%^%JItXaAulmmB(HW=ph?c*aW228IonF z2iH$8Xm2;eUAuo4!>d6Us?h%CkcG*xjdDPt?d9n$Oy$w*W+g=Jh==V8k4k2JXYvPY4{k2b$=A9c`BX;BXlz@v2PjCNyx#&ci!KxBeSi$2PJYVun*l%OwUg#skrIy* zB&f9TJ^CN}4G$u59m-Qw;>CCo2~}G3b@q4lh#j_qZqTcQU~xf$N{hb5{-qvfLnqh_ z*C{1fQjnn1VvOTBryd*g8n{kr!7{vvgeon@0*(i47xq=?L_aMn@p6I$l@`87|5J}b z(Z=XQkf*$01wn#Ji^+@=ntJGnJ_wuPIu!*g2@+J=N_&^i(h_7+g98Z|Z~gN}Z~b!c zV-5yx04l&>mlCMFDbd=?PzUQlKAoQVs2hL~16)c#-jryZ%5ZI<(+lpB_|E!p>Fm8v;*@bngmqdB!#I+ zz{YkvQy1i+PL@Fi#37d(kk_r;Egv=ps=6Q#b)s(C0(nj{sJudUM}UC_NT4pP7a`;5 z4^A?uyiBJy#2^J^Kj1(JxnK+E4q$%(tqLlyT7J7U{0~TAJD@Jq&o*LzaFRjgWjeJX zCJ>aJ0O9&!0xCY^->1N;KZpA->t@KsFzaT&a2h9J7bh81UiaGlC9Inv z7t*XdCErB-PBN&xcPfK@5e{B%hS2t?kK;J|18oCZ709dRt7+=bkPCR#ru0LM2>|v7 z%H+@W|Ej$9GN(A}X2``qZOY9P>O%eWTgU*poMcdWg)Bv2-3+;LP;H7a3jLDyr)`{U zq4K6EfE2QBhS+NW)lE9)5R6mQ8!~XLkZ2N6d6N`6Bv>~?92Nl8>$u6l{$ang%4;uk zinDHpIBWo#qnr7V$aaaO0 zH{I6DbugEr4bUezXQ3^eK;?C!vFEXFhB&MNa(v+d0AxV@c3Vi&T3;egP|q}#(J!3ZLFE;)6oGX!j1p>~dL1_zocu!NO;G?TWZevlN*>TWM6zDcg0&6$0@?!l zqdx$h+Ck+NvJ`=JGb|?5K+aV>(1Hx8-`*!B>F5_KFX&PN*3GcE5ChdiLaeVaSHL#_ zXaj)LoTc*mDcyfrH^UM_3RJJ-Bm?Ad@(Y#My>@>I>tGrB*%cA#H4)lWWz zVOgODa!tq=YGAF4wH*Ay-VRRV zgUTx`DFW+eSWc*c92dAYgbb)3asb#DoP1N|^>euYvTlaug%rqFJMh_JthX^fQE%G9 z$v0JAVM`HMH^T}-4diwBS_wB9*e>=;R9<_TQ=D}(tSCf4^^hNHeym?GUIW+;PQIb? z`Z?TxSvSKcWMWf*S&Us3F~HfdewpL7XOyJ{uVV+1co3+MjFwBF~O2 zL`BGl0EiRNn8-&S;sgkUd^R@X05l%rC`X)tMngXG7)Kcz3;D=nT%v{?$VVPzB0yo} zBeY+iy5UFwRLQ>V z@Bd+4GQC%>>erK58l;7W21}On8NE@^;+k^4f zq&*P-P}&9;Vx0LczZ&AT$HTUNuY+daqpw=|h$9~reHqahlA>|-k`no!#C5sq4_!VV zu2nqI-)Og$MVlC*k)Ai&W2DXSoeq~`Dr|kwgAn-{7DjoHMhNi$5Lx}acmncUeuKan z*v;7ONX0bE`H+>G<{1&!dMxLwj<`oe4_stk9D+ItTe8UGQGSwSkCaj@CH(j4AlE&? z`7W}ed3c$TB#zl%W+Z9m&of_UG_UH!vU-~pKUJ|mr)rEQ{mlVAHKR#&leQ*C6^L@> z-fFuKulU4cgd?_k5;wn;@aB;to(+G!IC$*EA3QV@m$|}X0L{QBY?+?+))N~(Fumme z7o$mVNM&h|(Vy%qY>f(NAo~b0Roa9j2jdtmz&NIF_qh`2OZ=k&SZ^PX6sq@2HE*q* zZ+|$t^Y4GeAS^$(i0Aw_onnl%gh=CZ1l4nODag=yYq?~1muPaDR5d-*EKjSR7m3#v zNh8q1Bx-=8=e2wEQ2Jz^7Y#2GNR8)(nzY6|jwMf>l1sak^que+^Lb5~$m}5VIGdRp zLKd^xRWrf!IFC<}_+3AbhlgvyVd3GJ$HRhy!$LwsCCp&bgg& z=67HDoH17;zi;biN#dBdkq;Wq;gNe*#>(ZfD1yfV{{6TvSH1N6yLq&g8yXuuq-sz} zBQ(-7cN=Ll#N3TE=InQu*RVq5Lp%V+e03y9ki2KUJoCJD4kBp-*ag|;)UL=h%Xv=8 zG|wfNzU@n~)94(|kwl%tna>f%n8TO6zJGYKk>nrE;WU>qhd22o*&I$Y`OVo+Cq2#L zG>3B}!5rRFR>ODoj=(>MpB-1ClQCL2jS!g6na?=q@J=Nky&`Rjl{`iO!0qFaLbc-h z8#_R)Va`Tq%;D|7Gw1a0j5!_o1l4nODX4U4XeH~384}XuG_h)WrdgiW=Wx~YIEORe z@Vxcuqc{J%p66dZZ}k{+`Leyn$V?MxDeT4Rah$`Mw$I^QJ^Qa`?Zc%GYacG1&B{kS zF|F;zLxMFdf<0^I{A{e4>0z9kp*vU7h$EjXX)wHPRB|G61JJQBA zaG;N;uBmK!9#_KfLd4;DJlV3ZiorN+^}Igp(h_1ABDlvRh2)1}C2DC^=a(=T+O^MU zgh&rsbtwkvar&nzu2yx_Q=!bO2poYXRZXAlrSf;lYSWn8q$N1#X=UXV%1GnHs9)59 zUjMG=vCY#zGp%&+#*LnJ#);8(PwOM2?_0QNkB9%XF>lsG5(D@>lC2M}Dp?_Y1^prO zyFT!|hh@JNDtoN|A9!AnIp=+y^~`W%KEqy<`%CUS>3PU!oU6@4UDp1k4c=KJ@w;kO z4d+QsJW@>X`hxMN4NG+XeTd;<`AfVOlPzyyIWZbygh(3%=8w~A^MN@xXD0ig0ZmR5 ztEOj~1kJj1wN)1H^53?ANjj(>Hi+|I*!`Z!cS;^o_S_;~A)JNB!khA@7yi z{zOD02_bMme5KnjlRN=w&hY++kC^KZS!U(#d1cHbdn*T=HoQFmZB*%*CXKeM$AY9A z9$^Yt+a#0TG>WB7yI<-yNHex!kFum^2Ez_{^M4tT+RzRU-~8^LjhPkXQ1b2}o^d2TF`lfN@Gs z8m6@m3-xmRjLACFdRJ}hB)5-njx%Yqp+*2g#*GZ)$L*okUlVW9_+xfnN{T#HdZsP@ zR=vJ#8j!Z39sCmeKhwoLO3yN;wRhf3oE?zbP{QQ4x%HF}wIPl6M(DAE0jUk`K#6bl zw0_nHsz_sLQ{?>Y-vd$`C)=pfGfi5pV(g~D0j&*ZNc+e@=~>3K7O?vpO6u=v&Z|z+ z@MuB%KArCPG1~upgr*kkO|VTe=}n_p+O(~9aaTb0G-_cV1=yo3>6yXs`05WFKTr3c z+lB(t9{=Yzfpcc_e}1C{yx)9KH=%3KiuV}%8~PGMmNBh)FJGM!kYgGpY;dw~X#Hhb z4Q*8EnI?@^{c7(`0jbT~kA&a5xo|1{=85iu_kUS2iESF08d75`{3N{Is({pn?Y`;2 z;dkF&U)s?&EVHzk@IsF(0jUio{P~T~j|a!)Gqh2qXPPux-x)I=3rKC=ap-BZSADam zF-^_2pOzFE7m(Vp-G^UV7q_rMWk=hv%+ltYfg_s)q&Ae0y$CBCReGjLqvg)m>&<}F zCjE@j!5vB!O){p@Ugu0-Vw#$39m9SO%zFfEcfZ6njh@ClO3yN;wMK_dyc3YNp@dCr zv!^OO)1=YfEjZ!cfYipRr_na-X-rddt<=PV&jzG6l#rva)Bc8Kqz&A48YT7jCg-&P zX!bkIxE7ZKwr3-QLqI>8&niM(SmG zcxymvW7@%I%9#LdhK+jiX8#>|^>Q`e@nxQ$OP`-B_YKeKV10Xw_r5&RDzC0p|71*H zo^?8D!=7gCXG~SC9YTQ%!zMV{=7vdlH5GR}zA$O6J09sI1DF(2f5#&%DPxk<%Y!O5 z=<`;Tu7;?uK(8BZ3ZE&gUk`cd!wj{`>r*!Dyzj+h1@#P>OU;__NJ%|3a$$iR-{#jd z^ z1zqh6TF?tI%hQZD9A{}e+LCJ%t!;}8&pBxmus!uf({I%feyfhLYaSd_BmPR5eyoTu zVc;K8`t~=r4M@nCNk5dQ^lQIuETyZq)?VIH;`O_xH8{6&72V;5J(F(!QeDq(`l;WK zt6F}{zGC%_r(ez5-l;YIbH5c+8xa3S*WI~WWj1z1%wxzhrnN$OU%o$}wYgDq#=JfQ z3L4s|(lbpO?U&+x0`sYH@%4+gg1uoq#zQ>AB`G};HJvIXXj$f>8%HtcCkTeitD zbXjabjsk4=qR;E)yUnj^_zm+YJ6xCsq1E|& z^Ow=J2e-GF8<4i47VJ%SZ7k_cwXAg0C%SbHNNuPEJ>A~ZEa_<^hB1A{J{*wRn7znn z3Yq|I-nz6p)3!Ca^!;-SOdB-0q2BBK;1O$E-0)2FWu23LSVLVtR{KE1G@}ju#2S%J zRXLk#gEnV95RlrKe&eH!V4L-oj{mvy$sGErS3);;-qlQ3ZKb_(VN2UIqYXy}+J?5W zY!f+Znd2$Rf4*BYM*$yg1lzoGuwbR_ald*6>Ou9VXCdPsP#qv2uRyFX=CQ;^c&Sy+BYw)e8{fNm}y~O zXbGBryoi7FizqH3|CF@dpO@ry#BP5T;mi87nXkIg(73>)kop@Zc3%6#uIcjE8v1aa zQodoz#}f4Op_8VU_#;ux*K&X6{mia%z-h<79zbI^E!2GSXrENxm?faKOUZWB!d1I; zt?xM>(ArT0*v_qIs`=#6uC4DjBp|h;&GdC73It@& zbkjo3r%knqA2&aeW^G3;T(zrJbbHcwafwy&Si^sAJN8KX-;7i(*aMlLY^^fu(TBnEbj#&?_JOFaKbNhc zw``s5RlN39E1#{w)qu7gA2CSDc5|n%8rrc-QQsp+qnbs1Tf_Pju=e)gHN65-JN8IE zG?S9;rk<)?rsL=c->=tl%w1k2TA#DU_vej$1$FI8gSn269Ry6z>~fDuo?Eu-_*1_@0qJ+N86RMR?cB6;n<=#8 zL61284eCF)ojI!bOdBRZJGYVFbjqnH^Fe#+| z)adU%ZtFI>j2JY3wYPaT-^f9KO-*+CA`gwp!La>DG!` zui1kOJGIt--WSZCp5y^kH-B|&CGGz08BaQC7qERneRPv)^gXv8-+trVz7Y>Z`5r#l z?%?syYFVRLwhLoBec3kB_t3Y`_g%24u9ffBidyf-Ydz)ETK{=ppx5zs3&w@KbI+C< z)U24V{*vb(?sA}ozTlA;Ub?wBuinM;$@l4o~4*&YaT z)1tGf-E>nsYaQJ3ql&H4jCO9eV}1kErj~YL)h3?{NbT4od9w*U)6I5`(oOyS=9>Jz zT`~HWj``YHJyt6^7=O`Gv%6l_N=R2#kcbi0-31{C+L z*!gku;`i8WcPK3WazOS>j+w!>QN>LQHQzcJ37P&)V4g_QX1uWo+o@V`M&PKT&J^0p z3!jV+NZauN3e$$hI@oRGr*_H4%)GOvmkCJiOutL=m@g$AT{yopaO zoq8ty%S~(T#A|Ok{w?f3Ux}IimgG?dw;rhaBem8NfB&tN-FD}*V3hE*?u$Mm3-Gz1lbWz}|WR*HCOA-V<|cC{@ARDNcIzzL}cO zhALd-yRHGXG3|uSmXGooPcpXHjw=u7JCbou)AJr6=#E} zuBYa+j!NfeZFA~T*G*xr+K!fv?)|oT!!vubC7$$;QG>tTe;H%cCX+UsS_u{Mhi+pN zss3)c#h1V<(OsEV-#zG7-o9#wOaHURV2k^OvV^9LO89rnfAyI4_;^7#Wp7uWd3R&S zw@e0%3sC{yxUr8le7_l7$nDVh>BCJ|HI9k$?fR_5_9hu?>ofB1{h>~mny$AU+cv7y zyM9y--|72GG|k<$mPH@`)BZ=CdQHGI6dQmU5I=Fh0B)%B6{Cxr)eL$QH)OTw+8?o@HN+ZmOkKFodJk%B(Ge6uc1!egz5 zn(CX|IG`Jf4P?J(LwB^h-kmCbr>^=+)k==Heg4+$=<^oSnz#`rPT_md`vMrSYx3Pj}fhpvyi^Gpa~Mw1o+W+)yZs2f4@ zfX1u`EE-%#<>8hEJfH`S{kA{y)jgk`2lSxHBuGG=tVi9{8rPHZP{D9Am}!;AUJvLY zR|Xpo(v;1q9$Y`YpuOFYr}EhA0X^!l>w`SEl>_w2ESOa=hadsha9eDX2jBL)hYS)z zPPcU@ctDFo#%zKF$mzBO0}p6%Kxvl^^13}*0iIlf_~;+MJt$El?sh95Jb47cgLWVw z?)H!a>&Y!N{O}<7prhNZe%1pX^UxJ62EW@t0Ur1mK96YrD@$Vjc2Vb04ld-$Cv*i2 zYX1-FRHqX=4`>St7V?uDzi4;25f}AaGHngMLEd=mH3PuS+J_2mUHc)S>kf)f? z@H3I%LpxF*^%e$rP)AWg=tO{>RekLK1A5d0od{2DiZs3rS;llk<8N^+w1@U{3=T#p zw|5ZIlNNM9J5V5A1A`Re_5p|Vqy-Jo4y*%>!E%KBBBmQH=7Y;*EX;E(WZ|ien zewuzd+YRzy@U;)d)Sa}j0qvlcK^FEO46blSf=Y{efOg=v672?^ArA(};({uW7JXFh zr+oGu*FYV(4hAFpz$ZxqNDF!GlLHF*lsV)<9k>n#sG@=@kQTP2Jt-p(bs!IHfa_o| zE+I%zX)&g#;|ia?#Wf%+u7klZQcwlb!uRNZl!Ip{xDITI>tH}EDM(Oh(bw($9dxV% z*MQEr4kn6Xf+~;}eT)5za_|fX*Fjt3I#Gh91PLlF#yF01X50Bp+635~_9`Rs(q;hy zl@?=xeLMgSU(t#-X8$QG@p33sfVA*E`kyJQ^^_&rhW4r;@$$B7sI>4IyWfD6&nrSF zwsS>^S3;ozq=nyb@lF!%0?@C}C(zE71?vi`Kw9{XeIhsL%%@*)4cGwJsUlciFd3M% z@EiN&ZqS)!kOwxvb?z0cEtm{UTKEkYJ(Q7qaL9u`itAJrj20xQwD24I!oi?3>%cW& zOI)X#U`@efVA5ht;kZIMxYfmV(AROD8iFx`1eF&4XJ3?nj!zlk8t4HKXZS+QziwoulnUP=#v6x5+RNjM$8v|8ckcT=^ zH*JADCmB>;A-f~M;uJ`rF026Yy-&4bZSE^E`jU^ex3U1XdCtgTnlwW9;b0ip{lQc_UFl)46%p?lAnG?e_);L4@}#yukzZ< zoZ_sTAr{U+)=k^O4ycd50T~c?l0oGavJ`=JGsI#U$huSVP4opP8C2dB1&~74%@B)Y zAc5@)y-_DZ07BFc|8xWLx|K7Zbu+}G7)XA$E7~3PvQEaCmLdyOUaP<*!nzq^aSvqO zY*)+|s1N-D02v^clME^^=u-mL%@7*{AnRs-z!-)4IUYa;#GPbNd4()RVBHMWO+62d zFo$5A;=B$S?0(`@33;8$Qp!^g1bBdkIRy1X76AJLebt|v^q0Izb8nyGVS@TCQOqHb z18rd+tDR&}d2e59QVJeKupN0|hB*Z7fH@pMTd`hisTbP(RuO zKwCJ;;HQv&ZGNYa>C}ci08ziT2|J)Kpe^jSaFRjgO>NzzuvDuLPn$pf8{;?6z={LFE;e zJAx>o2GRyR+{Ijqc3_>f1;;EYvOwjv3Q`#KH~W{<_<*^>Nd}eIUY}E(bu%m_L_pS^l3!r`;3R{}>r}5j zk99LFErmd{J$)vvaiEJnVfPD^aojZNj6mhJmpR2*H^VYQ1XQnsb*?G{{L^XfR(XXi zMPS_w%L+A+z?(Q&=VFY2901f0aB2sC$*r43OuL1wn_)R21QKp1gVVgJ@-pofvTlau zg%D`=E9-_8*4pq-`}#qWj_siGf-WUs-3%)TF;KmZlMJv2=MQ@wDzClFDbBhXRum#2 zfj7~x-iJ@v=WfuX)E~$Tx|D!*Gpr=UKmxDhCWF&_q4F~A7P4-Jm4y&U;7v2^JFtep zcnN?Vu)m<6AWsGIs`Cg55(thN%m!&3tpAZ2Fd?P>hKByn#1c0`1lEF_Q?PcD)W;(SYZiEBX_C$X` zUqD;fZQ&$?$}22)1h{bxWILKSW_9ep&<^lT0Byms+n?+IRe9}YsfptO1^Yt^?AsV0 zP(Q{90BzwUgP-E>`vo2X0IFYbLVrMCKwH>t;Ut5~D=c>eb%h#8;CSOUU(hzBw}<4l z=Q+hWS22thA|UzcXHMfJ<_jkoR9>fg?Rl)5VT=?4SvUKa)A)e(tdk5Xuf0B}IO}GJ zhdF?(J0-us{=!KHmDj0Wdmig%s7oQxY)_v=0SS@vgR$D~7m~Er6NnR3Ugo=nteau1 z5CYZfL`t421N_rz?pAq)EJa}5481}PG;QkR^`ayX<0Rw&pnd@6Fcnl@wOmcJZiaC} z093EzBm?Adnm1KmwN5q7x*66J0-)Kie7s&!$-@|hwg9Bm4l1vo!~K_aGpsM9K=nFK zGC&TeIZNeruian5x*0Z*Y@lENTi>K9CVB7)``j(b6#Bz0UeKikteas&AqJ*K2DF3I ze4+BDR6ojCH^Z)NM<3P_G`+ED@CYtqv6%n_38D-G6ygAcCkXQVrBbP(ht1QH++@)0tQGBhaY5TfxQJmLg& z2=F0f9A)g#2pLB{IsoVqGA>c;t_nH;5HtW79C3s|0v!SdV;p5jgC2%rT%txA`7jX5 zczvW1hhZ3(sO3;-dzAejm@SY#WBNJ#L!bIbNc9heO&X0`)7e{DM{nK-R}u)q_b&RI zUGJ*xRX8V&yNzL_5bB&7y-NN!K6Pru?^;T^qogmk;Fj3+}<{Rmo z0zpu5=KsgudB8R8ynnnX;$Dbb1l$Yv9yB625L{pPK-_z8K`Aa26&He{qN1oEZp8sY z+#B~6_r`&K-SeMI@}$W%SK3nS-|w$|z2I`6T%Wt#<=yA*a!L4{*j^zzsn8$(acoj7 z`C;uMj0NcjAeX8Ng}=))w?dt+DY-C){T>T+=yLRVp=5Gl@`j!V$`Vx=sw|Fss~*|6 zSFCYv9x}`oDnrJq%y#tC9{Ch5%&~j$#}3=8m}6hh)C1_Sjdb)y$Jah>kum0jDg-{- zx9yo^$66(=P^{gfR2C{}?NmI6JsYCKwW@YR~J8(%fZd(SkSZMrosBF126#f@7 zQlWRpF_ATqhZ(BW9~F9coJe1T-g*(U^j?JcUg)%w7wz%m;3ZF?qZ&ycD06b0RXHi}zQRf$5STN|Zfjjs~LQOL%@CKJk$ z7y9A2t*~ke(n6C%lj2PeaoGRYl7|rn#}DMu{M+ML@@#8P$YxyfaGwX+$M3qC>9*58 zB~&vk$b$V)?RYaGpSOoU%aG6eA0cn$t6NoB+T;jB{ttB62J&or1|#y&hb2zMZldc{e^CYJ}n_L>l^_pL;p->cqZ}6V?i{DVcxJ&j@|`U+ly9yl(HcOqg zIP+`T1LevL2P@tRcr0{+z_)RYqfh{GphH|t9{4=&JLo4}_)FkUHgqycwZCngmoWo7 z^;PKBfjEIGbiCl(&^GiuVH@Z~ZZzVH>0Ob9L z$9b8U2~107k~DMHOqmqfEi4pSvuDp{kv)6nELpQ!S!T$f$Y5!i(JDiR%vM>lWXzT& zi&e%fSuC<;%(#%L#~cyEva%C8WBE#*cx%kfVWTc|+I?=+aIe|xvM)S1>~N2=dA#Q& z9{*W&RGy+`D*y7n>bE;(zSp~w+h*h%{rZko{~@j+#masCn)7V`CtoI0CBEfewk7^S zip8V2$=mNH4vn0?t@TyEn>osEEnav0V5?<4I&Sr86KQ?eO0n%);{xx%If=T01yW5U8Y``?Wn zvM?Z{d$HsGr#f8;{&l`ll?Q8v?RcX&@7&gZW_a)4uXv?Y< zTSfiMEmv9$2pRZa`I%xn0!-b@cFo(~sU~@!gYl-Lo<3VrqJ;NR;b*Db^d)_!wFnpD z{OVc?ofhcR{K=q9uA6dEphG4nlqJsF8|n z%&~_z+}d~rbL>Z7S|7^B96LK5^?Ez~lc^J=7i8+Bf2SR+jyeeWXWRBy{0c4a;`Q@w#l=Ghd{x^=!#bM={%Mn9tq1QQn&+S;|p};%Fay^`Tgju)%bl5nT7zEV%!FR(<<3laAHDvV2`Th~U?yaV{IP%hNsSJ|C_OI0)DvHV zL01)S&5F-`v)W7L!#sx*v)jDlFTq?=o;q@A@8Ex~E1{a<9s}kp><8`xg6A(M^Y>^) zFlQMe@AI~&RQYaW>2Y5_{in%OWXzZ`gM|fx=tYAT{S@m(lpXpuo%Z1e=B_|^a^$6pn*QcZ}g&S zhC1|$XC_pkS3ENzOJ9+l-b*y-OVb5V=$?ORm80Lh9w(HukCnOBYtb&{hGy+rl)M|K zglgySB0wc!KW}*2b~aRb_NknkO5x+xul}OlnKKUPE8OkJf0{nt?|B^Ta7sayhI6lTiukuJp42~0_q+W*`I`Mr3??JFGvhc4o!?VJ;Y)E-%6f6dd)a<&}+~u;?colEkPNT{YlV@M}rIm5X+ZSM<)Z@yFBZR3=>Y}+$mtWqLljH33Fnk;cBM8tir z=ETNPh~m&%D3lxPy?>MctT>Hi8=4qzdWggRznwh1w`t$mHxJF!g#Fz!jVLB$$AFI> zAIWN5@=C;S^e>U+igMSF4QnGxU1KQVKAy?fMlJogU5NAd1W>Ra?jZsl;sHa79C~?r zs`K|M$EY&fkI*%T`~H^~{V?M^_A*Rq|ErdYIn1#qGspgeIrg&5vDaXZUA&EYn2-i~ zo3AEL4^YI-sC#hYL0?qaDqXhinS^Wh_l!~4G+x8f8Gslj|gKb0`qyh4_<$Esf4N)T6#xwO$f~f~Y9&97pAPtaLqfX#kpxT%7K2J;@^fqTRy|0qY z+4mn_dSJoNZQ31bGgbkF;j}>y6X~!Ge&^>rZBt0{LD*dUH;M;mbfugE6F%dOd<3z#XV27jb>Q3P2P#_CS^Y=t};^Jwr7$Y zdw-;;0?lcnWtM31iP&JIN@4H9+Ege;G5aj}ov1JT zg5UlwS`7FUyWO(Y%GlfJcFP@n+C0nxHpTdveSA(YA43fs9M$ex-a!<L2wF&p_ z??>ZRSe7^7xXJnLK;^hyO?D|h^d29br!>;7Gcf;9ZJ~RU6)PqxFaOc{#Onv@`NA{% z^4XPLDO4!*f%+urBs;jSZ++(8@_P=kKI^nNysY-q`;BMk9^&yRau<7JskA-|x($y0 zqxFf`57g(HhdHl}UG7e?l_{!El1{RN>-yH`%uz{R#QL1nGuPSDHGWbv3l}=${e65W zDy+0V-`E$L^GE9wuOFyS)wKZwJT8}@P!Z7w&QFp~vV-gT*5`mBJrjxb*{^@|H|>VI zHlKgdvvIXMg}b4GO6#-Q#mn>mXnp!%^;RI`%gvs_<0+E9BkAh1o@F(EZ%I0CN8kGV zoWHv*u|DU0Ei`Fs7OR$i$^D{UwTnC{)F;|te?QkQczyMc)F-LlVpJnkaIX^t9IJgOevl5bJYoK-be}a%Z3-Pgh=)aoi(2&H6l(2;v0tRiff*I|U(&44$g)ej%hhKc zWA{Jdyu$qj@JrJ1`T;w*p8|a~)=xn7Idbus@b-JgQC}2YJMU;ek$SxKt;Mc)lc}M$ z*Y@UKG=++OvS)jif-1KExhibbL%cqPE_~0}1u^-~gf>&1o7$n+mEmhqeJUQr9)BlS zg%kOuwx|owj}a883-2JaT(`lPE}5$TbFoEa?M&69$8UL(&)#}G>cVg2n}L~o)%Fn{ zSD}(mCG5v{^XWDA<2oK^?Vz&dMO$eam_WmkP5_erCr=DC#Q5^{Tvzdlfeu{!8Ry>0 z<0sR+wfQD1@s(-6Lwt&S*NWu$)~Z?Swaq*xUH3hc1COH&xQ|9tzz!@le!3o=vwK&Y ze8F|G=fUeq|2}@CXv1WAD8OdnlXKidak@hhnBlKGzs(;k8-quw=^BDL6c$!|tB68z z4WrR>NhC5K$KKy6d0OVPX%bf9{k@<4hO%Q@Ym_^BRF&eN;eI*(zc7f(BlAhE!AScB zUBwv{;%pSvK-w9EA7OlO1cL>VPGXa!<977I*K z%+)`z)r)he>}m#|6n0xA$KY%e_(5^4indd02-1E*S8>LKI2$z%gWw182_ImSq~lD1 z9g>dQ(U-yUM=PwAFbMU_BG8Gl&soVQeHes{B%!D&_yS0F3lUK|L6h6i!r-^rKP#Jx z!5Vy79rw@s*}PTbY;OLy-`)u8l_3o2R*K)uQc$#&(}JBILBEx(UyL16Ws)3|rs$iZ z^2vNsYZ%ggL054`g*Y2E4wEo=dw1hu)7kbTC@v@F$#wiB1xY6j_DDKzM_(pwt9IQh zVUl-8ExdZ>t@v#KRdD(4vIaAW3d4P*Rm^I#eovha3IG)9$zEGzN$j}eP$96DAB9oQl1 zxE*~tyxe0`Lm3WfIIF`4C!IH#LmhmfkP(-m?tDQ3wTD_bT(GcyfT=hXeBt07^VXhl z$nKV~>1}?WK%0K(Xw<$i>goRCatxZsh&nL{KCEyz_xPap>cs`%3rTwQQ+*Y)kE$=8 zgB_BN+tHW7vz;?NkztTpd^upl?%d6(?*5Zc8O&f>d?6G-o-y57CC<|%?>OLVDh7oy zqLbsmn%i@Cq2~S!zBX&M+h%mM_-Ln+q>geHuXFW=pC^|k2TKOg{CA-qewc*4zBCVVE(GR zii;VXKlI@FM%kxR*H)Cz^sGoZ`jrdJNV^^?^!PV4c8J$y0`=v9{2J@ad8c!Yl!HLKj`DQ zAUJV&xq_=&uTnKAU%XarA0$frBBBlbp>}1v8No$57BzEe@S@`{{32qUGtdiQi;mC! zu-Mbd#g8KCBs;jSFPBw<8;ug5HDy+=ez|@DQ;v|@eRJCkrWM0m2OG>~7UpD<@|GfS zS&q+$Ny2Z&ci0^6}IfM|~1VTUF3ioSve*>`=qk=cYA<;waCwU+?eD`AhoJ zs3UnoeM_>Ik#*3=VdKT>oWG<=I>`>M>&s>4yuIp)xtzzjG1_J2r_FCGPo^I3f4;LWL zJ!d!{Nt1M(QLuyS`m)$ATlUN1Go>`=y6DG+r`(=iaSCPC?OI)fS=82dEid(v8Z6%C z3xLi}&5sdSoa(o~pUGKtIpZ_9=cxoY|F%urUT(dj6*^K)7Q^b_Y%9m2d45%=xg1#B zeee4y&r%utP;ffI+zd%~vN-+gb3XNaEZ8CGxE+02?C!Ws@|X;`#5de3scqo?PSmFC zLrxgXBI>Vl9~pLJ*Vw4jK>@&mG*qXP>Ud0xUu+ht{H_a&;0JXL#YG^kMHS{(Z!1TP zzB|jhY1q3AWjZQjcA+mz`m5-gqu?Kx?(DNuj>+-H?5m2)ueqIC#T&X`_@0W(Q;4%s z{$bX@{20 z-?wU^y4R}g`UV5Mk%cMD}!qJsbe&mL{tUyeX;vk%l|4IKC={MsOpNz!qmzz#{r z?dVIOU9K)A!~_biiSIVXJui?x>rjP^B;<(5lI^!bVo^GfWJ4_kP8$C*gQ*BC!xz@^ z!n5cq^zr&<0@AI1w^zX0a7Fji%W9Z0G}sY(davJ|sm(l%XQBXBI6k1` zxPcv#j@!`}!v=-#OYRA_8h>Mcp`5Z!Vc9))i<9WpkB~YoMKYH_Cj^=U%n){BJ&HYh)X((Vw(((Q!U`Wz&JNjbiF`GFoXi68-|lccGzWd4C^V*-59$mtNZd5|8#Vo*7rN>2*ty~no}>GOLq)M%$Ynq zVyp51sjku0g1>Y1X>h>I9nV`Vp!~7br=T~(R-f+byS{JXz6&XmPO^jR`eInTBDl*QDp~2p;%7FoATPM!f zzzX!t*kaS)Un)Fa?!JH`={TNX2iNt*@cM)I@nQ_SEIV2FS;zvaG{4p}vB2CM24k3& zITJ}3cH=YR&RR_j(|xgNoo24tO^)HFs;~2RdwikQz79?NvL6}2UeuRhSoh7xW~Rna zW08~8JEk^35Y~`#O)dNvbQPQf#$Q{yl=Fu4q0!Q{rJ(P?)|T$%ydh1}Np^5uUktZq zEL}~EA@8KK*8MqiUml79KM|C1R*gS}y8&KqiA1$q~3S?Mp% z8`2~l#}n+}y1p1rFMH;_7{kt-lcJOPRh^FAuSOY+p|(zGcd0kjz%bpHm1g?KvxCVo zoEti}%wcMc^X@@G-*&J2+*||0=e8x+r8|ZwSMn!SZ>J=G7wsW^U(i+D_k}ncML*wZ zzte)pgu+*R!jub1$5)Pm9g>dQ(HFx!9v39nDlSjj=6TK1kAelAiwk)jF&IPCDdj%W zDn=S)#3$ebbvh`3bU(z@=|GVWwOqN+`ftlix?rg5N>WHCE(mEwso)K7bP65m?dH@X zZsWZHJsW(?hrTT7l-9bxCf_(;|#_yEf*}H0OGS+y=?>xi!^_?$>bQi|L$0=#m_yi^IM+xSrh-2U7RNA zlwR9(DoGAQqdzWPF>!+Llf)ou;YjHyD$CM)2f_lDQFJ!D15YcKqM!|m1bki9bj~uW z{G8n@67s9>fVUpDsQ3JHL6rab;upV(?u;kdM<*lu}W5 z>xMqF`1pJZRZlUeV`If9EV_S8cwG8=r;}%2?riP8v2TFqwG1n{XGYg4oj6{u3a6Ww z0_w69ux`g<>)PiCp{%j~`-PbLAyqtriFzq)*bR0_I&NRzU$O?4bvuYpjBK^3S0Ni0 zQZx8R03E*d%-Y~zGWJ=g>}jg`%L5s~S!dRw z)X8!+;zyV4L!o*`pE^9IBs~v?FW4dJxE+0Q{CMF|lo-cRR~^2@^=R-;QTZ-! zTxBqhXqe4?H1UCqAO)Td3LxDNF-?20M;dCu@kEJ!7fp_1#}01KRetAM&ZzIzV^F=^ zt5NA?aU5#-ri&bofAj`U>14CUOr}y=_d-m?ZE3U_t_yMFKL}`u)8_mRr$eZ#B`Mn# z#RgGai4+RZmtvS+PMYU{x=kdVWCz#v#j$bOO#WgVRa?5nz1q5rT9&kCxm(u3v}K!x z#|_3&+vM{!J|nJTG_L{m#7sg*(wTRWs%saI8q8!`daO_Y@hPs}HUg6sHqNZ23zNX0 zuA#b+<z;Al(l!bvjVwLoI#Oe{(f(HaUm375eQeG~i>i1$kd2yT@1Ug^ohX zVa4IYWygws=9yGoW>VMiQ#YjkBuU5p8`vS~xE*~ttlz7*V{b5r zXspP6G`WF{AO)Td3LxDNF-?20M;dD3@M5yF$sXKXi7%z&=|@Fx&)#0H>6$ldGXA!` zRSW5CZ(a)Ht1E8`$T>wbj5>8r!TI5XIOuGWbQ~_QL(*|O`ofskuHr{==hVgVApPXR z0t&`xuXeQ`ZZM4OggkrRX~F{;@uwvpsMA3Kr28SJP6vv7s0GFuV-u^J$|(vkuJg0J zQafO33)PPs-s?_WIf{-#2FBN0LS$dLWxmF!6N~^I4iStLNjmNU!465s?dS`m+qiD! z#4y4D4jj|kdr?X00wZK3g-8t<6hOKkV(N6D$cI{B%Y7~t})i^ReQnXN>!WB zzUf`;_vo0G=qO|_YE-fRJx9(rnsL+#NAPJRj7T~@K?8P3I&Mc_9RKSf8A&)2VV2$#H~rVgM4BAORf|8?w>@Xod_m3*XMZJ3P~UBhU-Ccs zI^!id9L@8nI^jr~cLBWc`54ggt|!9`$zaXi+`eX$rvm{#evIqq4bPraxUS03Io z7{|0+&wv6*XcZzNYz0kjLyLE8xYGHJsc;moXV|tX+xf=S*k+4IeJ}AN*G9GrD;+Y{ ztb0fH=?8z3Lyg-Wq}TpaYYgFrGOUFJUB&H4kCzy%<>qf_MK0-5NYJNkkFBuctvdxp z%gQaCq)9r-4zBCV;iV+EPGS!C^xfLQb^9{9)TG9F+tr**O^xkd-(U`NF-ONYnZ|9` zFA&P(ji#wWf#ES~%RlGTTI5IK-~$3pbRJbjTWoq#Mly4m%$BnozLs zc<1dOZ37>)JAE8|Ny=gE*yLb2e`ub%(aRskY?JZ^evhQzz?LwBKP2h69ep{BdEhQt z0tfz3<%+H=K2b(Tc{ekd!?gHAC;&P$H9tn+u$q;nw=Nv&dR-sVi3>}*#YLF9$y9x2 z%Eo1`&VH31KbhIk@(cR1%+w9_XhH@#7|qYd(+S28V~Z@g@qU%YGVpm<>-z7iLDuoH zAJ`%3X`Q->YcZpg*eM=w?{ueVV2H3h{93Ihj3zQ!UGuzN!Sf_x^$nqIlHLG zKvTi!z#p~amw@E?R0S8exm$-iI%VxR6zTlbjbcK^Wl?4V4ZghJ-R4Kw&mCbJE5d;& zd?h#N_{wjvL(*|O`np4f(<}!uft5bkJ*PaD2`j=U&wabrU;?#WR)mcBbCD0!1g86n z@Lx}dMwpzydLwI1-@01Wbk!E`y_+tLvJ?|oI>WJBas(Rn>6BqkrHY;2+2lX?HrR4K zA~Qv752H?Ci@-tm#}=Y4{1K4%^oZ3INhjICb$tmeaj(n~F@X)wc8MOjbTzesUxQsX z+@*!V1myF-qSS{7lbq} zwBr*w7Fg$%m{P*E>D=LkT74PxlL-5`%>$HIb+G8vf`JZR<=SBk}1f<}cls)c88s_b@qs z_x--T>f!g+B|NlC!{%2CMXLFW_&(^19DnAi7@ekKfHRz%xZrUk2JKm)F+~G9?&rV` zNyqK$%U|f2vbn|leai2B^kVK{VJc=t(%c3H`#){`K}ID0(%t{nT0j4nsrVD7Vru`) z{`5uJ25ws>D@XjCx9};d4Va4g-X_^R8LCLL2PBb0((wf{-~mZGZbx4N8%)Z7T1=qe znD})oCF-8YYA}IW1-vwSj6z028nhuwm);9!CU-7=-{b`TE_6Hl>h@)u&GHN`KdH^E z#;6W}!1YNnF>*d|gn108%NP*GdiYuvAc~~peM+!H(s4Wb66jnh<&l^`xJm#^RW1*S zG5on(X}KH$1wiMd=0`-T=1!5KWenJ*TcH!CB2aixRLa!-_NB^qXgU9RnJUpCi+8d` z_n&ZJK)R!s$}FhHnhAbNtsz&rsnx%*3`W!zXj9Nt+>Z2E9>Y(Y&@Zv&F`ysBmd703 zl@wKC)M}cflkDKSzUcM-KB0*iz0uR7T~7tCrYrHQQzoBTINo6Amxrle(kv*S5ydxw zMpLKz@|a>>SL?J)4Vwiu%JLWiy^l3JP|BQ3U4q)*Z`aE!=OeZ@zOV4znC|FZm|9_K z<%cmmN?a?b|7$K+GBSF6R_TEr@2%+NW2F!81HJs|zKYpL)hp8gNs>;ogX{XD*XF6k zNilla9-pqa{(2bQg?|Kk-(p)j8H^r!b}k7$J|l{21I?zc&liAiBP>YmR~M3N@p@Eg zZ=LS6PgnFB+!!#(YTYZBgw7q_2gPo1WXtV*t;fN1M-OU9K1{8C4c#w%PsQac#Mvl1 zSJM8xWl~2GI-Gb15_EhL1?-S?+>XBJb(tA+RE!>UIAP8)Xwb}!2BW9#>N{k_H39rr zHw6>`_DDl@I;oDww4j$|-NUjV=!GPo z&%Et!n8(aE{Z?Bpxl)fky6I&Pl#xTve5paFOAY_>t3GqoweH>b%Sal|pt=02Pm&(J zXW61JAI1pj!465s?dXf%qk4DjmnT{I-B%e?<7Z{d9jO5 z1OjQ-#}@3j=JODmuX066{$e{x$B6p(Y7_p$l3ibShD$ zO`jX=14+5XE{AeW=_<#c*#qjtA8>|q6U$$0C+WDS13M%gx1%qA$1?iX6!Qnyz`+5P zIi7iOy6^`X;k-Z`3IK6wXaxR(><%9?6@P*UyuYr&%aRR8HJQ7@v+&)72esurJu!^=fkTl zd5(?&2=tAAvRjTo^Tl?Zd?1Y8LMCOin)s_94W|bXMbhy;CD z&Xn)xH@I4A7#&k8A-}-{rezce1%Qf^hDIQ8vtQnFrXoCnX)3^f5Uq1Q^F1GjJZu+CUbiC57!Yj2i1AX5Ok4nLB)e|kp_>1i% zon!~s^+j)fwk2Q1&TkBVvHgC#2S1wBcBQs1?KsI`^w3)i`6knN76qRX#hz@;`Uh## zDirtIas}Y_tEBzv402E@FSL(e?( zqLbI_#@}y?kIcY}k#xKt33f<2Zbx7AzPiWs6Qfs!zs(2+UfHVb+hZ_#)&en_s6a+S z5_UtK4hkUM4>5H*P~<}`{mxr!TJF#VJzZ}vf^_17q{z zb%I`aoODKXK7Y3@NhjICb$$7Z7<5DO%B6bzO|X~l)*n%@#WcEhzgcPH4{Ndnu4xns zWh!^u9^wlC>7}7Y(@J*>F)jQ(s+`A=7mXYDZrio@vyXTF=-4zc?_SqwcPsZp1!u>7 zEQHM6wioMMJtBvpc>+`~H+TcP00C~0q~mT4+#pHE?dXf)y?Mvph}~dC-VMV1|LJFy z`Wfs7(Q;4jqlpb<1S#-zPyp$Eh-un`J+48|>6a`!^9INfXr6x2i9jF?pEiN%7m|*X26jj~Zbx4NtrMa%hzW%07XYBr zx6nK3LLg*>69aK50K}!C5eOW4twmo`5hzT*)cu%y{nipsnyR|wt(3R_UGANP1rxg0 zFg1D_V{+*jJ+=B5?rD%V+aI~t;Ul;Hg|3KQO8|W?w$25nWk@>74zBBq-lOFGKgH-} z=NDWz9~y9}YIav@SmxNf2BT-gR6MB<%4bAzZKFB;(q;%(0Ico!XlhLl-_qjz@^0*M zR2THpb^7IY;GxTo5j~ybE1#NwIWdzhTkiQGLyF6xXYP0E^+=KGQv{m!_~q~TnE zRi7mNaPQ;G@*kZgqz5}B9k-(|dgEOtNuGuc&Zt<1zKOka`_o@5%r(t|YbXFzoHR57 zdP}Di?4=8OFs-6%C@v^z`bFq>Htsy;UYTs)TgIGndcEUSQFeY9`kgZ#{Cii9K=TBs zP6PsJC7vh;`JI?95CzYTAn7wVF8o18YNpVZnky)P zbU(z@=|GVWwRAocR(H>8au3*S#ijcbS35Kfc)a4nxrsg%&{2Q~JhP>WgPA~sm!5&= zB9TMV7q6YOy{GeR8cry%L(*|O`Vx3P-^h|;0>J~mqRKvvo}RFoE1}IXVUOqO4Bvsh^wkp-m4D{w7?ECjUG>e8a<^;d=jHHw7;JUu( zWjnvFn;5-u{L(X@C!OpEGfU<+ed#vFVCSdpVH2r6=Vc{d0H`2oXaw|fwR)XF7xdC~ z?sIqHv3-|i^>+(6U%uRc?LB9(NBL_=&W3X6nP*;f@_O)OYJ6k{UW}yU{YbDw(s4Wb zqBpc!zUN}};K9={@XGqKui^bpZP(l(BN9?j0O@{+838@(_}a&HK~L8?Pe=zvL?LPJ zlkHzJ`yGen&bDx&%^mm1&g*6!7~icD`V!Y$pHu5iPC5R}OV4!T50;qq#(JHgSI1^V zVd)u3C)vSuefe`bwBxOqKUjJe|FmYpcIyT7)L1t=gIyouk965DwHG~X;R}GyNX?HC z_^W-SQ6^pZ!(5+nm!2JR?BhBj=LC->i?U9(yV7zyI#PDr$3n;~J#)+zdq@sL^8~0) z7=rsE4cbUL?$*E#NyqKzi{Y@_d76tcgclLP{C~pp!JYsPS?2cp3J?8P8jK#g{fN{DP3>8q z!}$ULY|_vO=q1|QIqHHQ)(182V|I7tTlr|;oz3pMPfWI-)u2><_9*>NdABn)dP-@1 zV!UU4P8+bl-s{sUn#)O{0Ix^V@rwxH^+-ByM_=^Ttr#u) zuG?tWBK|XirqK(#E0YaIPg}n;HLnK+fQplb(k7Gc6UVglJ5}CCX6b^SuKi6&C(fSK z?-ab=gnsc8=lsgiI52ka@=b%M*JQtZ?psKL9D09r=0$uMn%k+>KWV?9t2moNoQ)a> zz4EUnlo|75EroX!#})HmbAKgS$7eXf4oS!D>xX8&zWd}}ON?P$ zq3QvaS65On>?-OLa^GMKwLR?`GLqt>#tRA{-48K!I#A?8Ef}6Wp3~ms7b?9c1#kHBH#Ik1FocYx_^9zpcWB*jOK7ZgCcA7bispvZ?>FdQ3P?3k%A6g;3?@4~i&vrKf}H|O@ITeD~u zLq(qXGt>XIEBk`Ve(zAD!2v?O{lym`?#2#`&eT1e&X2AC1l<)||G9W>m+H%6!)cOE zvV-gTqW7Tbkr!h02K`I>4oM8B$MefC&p#Y(_{+w$U4R(KWkhjJuX*o#y08DtdZ?04 zuX#_`3lL{Y?ur>yBBAN}WxWo*8tR*st&Kgk;$`3PZeIVXlh;e)(9;;-ffvKaYoOzu zNw7oGaXb2=S2^@qiWt3loj$H@^-q{E?yI}7pvqvc$6m)_&n8VT1sQSZ!GCqSbRYNi zDLk>Gsl1*Yf4q*_#&~~vy6Z{nxpbx2;N4eUkj}0DoHlY{1-V|QQTa>7^(pxaw}0WI z2c5kVdUoj+PW8jqe}Y~MTmSi~%JwJ82f`_mPO^jR`tsLk*P6{@{?3LJtdVdooI1oW zzjQwOA|g%vk*>Wb@)>bwqVSYScIg$;(tZ7Bz_WV?bm0$keMVXTDe&i*WSzZCNTp^` z6Nb3-DOq?WI&zM`y3Pfv$nj^Me9_DQkw$AI9rtJ8|42G+M_>M`jC|Zi%wGWS|6uk% z>)mq04dzeV1Lq+lbjGPaYX1iXQ126Osndy7&225CzE3kw57dP}xUjBkC@uu)0=zK! z@~O?D%#VEon)>G|pK^0Z*G1^dlF64*SH|Cz!_YkWq7#PDt;8{b$rqB2;|6v}I&Mc_ z3=<N$xgp(*;AwNPO1*(bb<5rj|3=n^%O%mt$|Nyfa$mbf12`UH$;ff&RslFBQ0TFtjhW`V;i6*y>N1lp*OPJGibddYg7VA0tL@ zPss~kZwwEoTkwl77xirU%wY7iz4u`^ml4IGr#bnO?yEojoc8Oq4hHLi8fEpT-~sDa zINjy8@1@prSKqd;cs=`LR2vcxX!m1iYdH+f9#Ah2h_BQH4@lDS%L(8CNjh#vUkr;Z zT-`~GAvh*jh*`zct+>G$YU_wXMjVFlU){lk0>B<=s7@!<@tBs5XmS&)nx^WA3LbD# z#KI}xM^y7zn|%E1^?;}2+465K9COdq=>5eW@C$$c!^FhR=Yl*J&~Q$GzH!0xJ#P2s z3%VEoxC)X^vV-gTqL=N8Q)MxFx%m4ZiUJp4=A8FJmMckkKse8xM!7Hei@L5y$4>AuU}j?Q=_Mp);AtYt^P^- z1zp8i6yj{uIE%31zJ=#)N{13)c*(}5x%YVmp-8$<`{f}XC^E|5-K5YqIE zfS!G5ts+lzRBS%;VAP-tiaL|nFE3p)$mA#gDo02L<< zjes6C^}{t?&`VdZmvzh8JSg|FSFM(_+g*mt!85#PPprj zq({%%J9@Fn&@(^iMW<;Nct8t| z2B1XJam2t5NyqKzi(c2hXETY>gXgcnnLj7PwC(AF9%LjwQ^gk=pa9bS5HkXLSDW@S z+4VjL{x}>oYipm=s6qP<(_1D7wPbv-5Td-nf`{qzjwt;N&aPQhVZAHogG- zxrzlwAaMWO`KEv3+0G8vFWuPU(PD>1&d=0M|9{b8N}hNYHNLUztNx6-@C>V5ESg$f z8@gZko{Gy*h_g}S%)F2s7&t=Qv4L)b4GX~zNyqKzi{YqldmO|V!t*!}eH>7@!9R=W zo>T8tNE3!~Rg5&qh}#eU)lC5ffIZSsoldIbF)cGM4Td{ZFjXJajxVRikQ=Iebrbwq(De8v*SfFvF7Sb`mrj@!|fzkaVb*o*mt zG2p{tEiyigTtL66)3LX~{As)02r`lqqvi?IAN9NRXGC9!#}-zAl_{RqDVSU6!<`rj@!|fK(CxhpTq=$ zYl3OWvdw-kOcw$nBPls*vY-Ic{SZ^914Ta6LSV({8U0N~pdDXY$JGnMN6j5}#BF*05Is_&SQBUZ3S8M5W_M>*&BC(%<%>l=@yR{x~^g0A8$3UM}SoNEu@wBF{Oy=ShI z8ZqchlJrg(l3<6V<975#Z>mF*?7JQ;{pxn_R5FMjb>P(}gV96Jd*MFPDn=T3Sv~M1=G+Vp!+Y#^~A1$TJOWJ`XuQjJGibddKDj@^ON&> zhjZD~pS^S;{i;@_s|KT2fH`VIz20fQ08nw#&^-EP;dW~kn zbs=u+=+geX!&laxar&JO{L-_YSU(c<6BwCu_@!qgon!~s^(FAc@u*5-=LbvA=3jK3 zIIMRlUDw}toWTTYyU{PTrDrqw0&q=<|JP_*JOLlqLSW%Z3Tp$LpHUvRB;4vg&$Z`o zx1<^^A|D?;;FsxcVN`6EKz8PndF6v!+3>=07@Ds==;a7;2L_Iiq%Xkwrr-!kI&Mc_ z4A1Vo7AM9KR)jU|ndE!iE0`YcT;4WK7;-#lVgniRyzqfK9TY&iA7bispvZ?>Fs!}& zab{gGgkhbop|~KV;h!C!$kDHD)#*=~STK&Ru&rKVQ{Zj=w)S{qh%& z0bxvcV8W_SufAxG_1fKtZF!=eT0gTZDXPS%)ig;b*}-*v`Kyr8^^KUn3DcupPX({0 z13MjBQ-!(xsAisk$p-U>USEgxToU**PcfRyh~na!PkdR*7XZ>rLnH9_ddT84y6~5- zW57Or@|^Fm`CpfXar?^^-4$rh9%YT1)7F|AJ*Bk1@mOm0Puef&D$b%1XQRgHfr5*} zXDngnlceKgIZX7K zNcTfboemWFP>bt3^>hCZUC`6j z{7Ki^uDC-+;xkoz=N}Y6x*uXjK(EO!hgYUT&w)P<$3sO51^?{5#AC(pYq_&E46BNC zn0~3?HpRzGV47Eb;^Q({^-0okqEaIkx1%qCDL?Hb1j1rW7~u_aJhKZ@Rx0B zBQP}|2n7(I(CTd?5Lhswu$QTPpdEiCj%^M&jdYyWto8KmRdU8gX8DM8Zsx`2-}SxZ z_%ruGb>a_(Z6t0;I_?3%4oS!D=*!==6LH7I{K2RU98lP_<97}AfN2^2K>^gviMNcv zpKsRYrtgDZ$kO@Nfu~vAgV$RPZLn$Hbaag10gug}uv3n}KRNfQ6j!?Dc52N)+AruT z&ZZD&qsEzlA$dCJgW{eGbet%#L(*|O`V!b{*#X%*kH7)dJasS8U;@!o&$y4YijkID z9~26}8^8ihdsqTKs-+KFaNUv8rt*No1kAU>wlA&~3~<{Y_G^a2<=otDw>^LCEpA57 z;NjmVZs{3?JFUR0b^UkMSVh$Fi59R!(sBFxqL-&`Q#Y~mJK5gpPSL;+3g$m@J~(mI zVD!+{ckZK!3S3)c5+JimPPz!q7evQcwWteu$~lfg&GjL9fuSaj#8Lu;RMUH^Gf%{u)DPDV!o{mv_eBID!;G|#-~L?Dn>yl28ZhYQPTI6A7y8EY_s+U|IVjG$t;P)!yTK)N4d>U5yU zhgt~CbadZuQxRy#m)5b-k(o0d?XJIK#Pt z@f}IWJssE~>9`$z`J3%gb%2;Z7>@*rje0&UkW?q(_i zg}G1n=bdX!dYq^6#s{kkZ47J4K665`cx+S;Ip_B$(fbc9xh^s*Z^61b)Xof+V()xf zC3`*(^+XFSxhCl(JGibddQUn&Eh0v562Ij7RlizZ-W!+F3q}=QV6gK;_x_=)I10tZ zI5tqEBygc3)g{*-_yRzBX=nuWDjs`SP#5&lb;)(Fi7%!t+U?eQkK4(Zl@=xcVUMz_ zWtAy%=$U6;bn<#|mk>TO120C>@qQ%OA?dgsebL*U;cIO%dT@XXT!7Xt3$H`m5vy-v`}U^Aj{(=ACS*}-*v`P<&kd!CrTTKxMSUftVY zXaBg>^hU+xGilGm;S0RBwH0weG@?q~nXy6}g&KI7hWn=|i)tR-@dYC3OA z%Xbx@SKWjTlO6Z55HdI2zV@1KA%~%P0#qjq!F`biZ6qCcYhZ_@<977L@IhknSz-*~ zp%5_tfAhzc6$WFd?M<7Ik(4hrUQht(eu$~lfg&GjnE?G>xyL(QFa-CeYbY)V$qfqA zFAi0Eu8Fzp+iKml-D{2nhdx1HhUph&SFg!(1pdh}pi+D^n%k*018KjYt2moNoQ;0aLZaN>l(^b1MHNdr419k-(|f!|}t{ty!g(=PykTj3S=(uF|Ch-(7) zuWkw`0PK;5>U2^ak7*&WO8xSeOhuqD{ZeS_*1js6Ax&4!&EMgNZQnU;`MaN(zf}%B z^B7Ps=XU^`W&xB)dI@a02Am&B$L;8gp68^O-eUA%Xm+8){T+9!t)vgc-S#sWJ#CL( zf{diFsF8vKNcTfboemWFPz!ofd?MGG3Ozf%w2n_E1V;rHzSv|_yRsSQEKbgfbZ!i| zX1M#r)UY zUrE++p1=-C$L;IO-{G6|0x^H3_T>vMAGC@Z5c4Zy|L7I;ywWd+8_b`!`;H(ZXiU5* zpa9bS5R*0;sG6Y`{x&Rj`NvfJ2@hVXJEQ3SgyN-JEq>nh+w0p;XP_gn`rVy}kQoCW zvzYnVjG@6jP{8fw#-ab7Ok7UG8FI)yxJau;YblbBV+D3dI&Mc_410Vnd0vcRT%qa# zmRDC&zYExg2JH%^Ro8~@G#Eo|V?f9VDuxTyctHWA`yr-I2a0^C1;fviH{CZmhK|*! zZocJixNf7A4O*TI;%zN5dZU0Fj!(`h5kav@Yc#wh=(yJdJ0u;q zuP=r(5A_=)#<2aQHdF8AUnzJ)`}ghlrVECUkrW>_Ug_=)k5ww_Xetbaf#Bh~@4n6P z+2j%OtKS>vN)|8K+NfB+OBOlw%pFmk&;!p!LWZQ{13s`r(s4WbqIbA`jFlKYa7^d< zf#A2wwuV1?P}?$W$cTg<6hOKkVroP|kq@|&Qj zW@yp`9fhPLnv(CV$=|)Al&@P*Q)>&-enD4pmV`JPHSTzDT9&!b*5y`rL;)+3j(03! zJV?@UJNjaHXQT5eF@`Wq3z^U$aKwk@bn)xMZy4+W(=r}}0zhL+Lur#q_laX#F#O%$ zrnRXs6g*&r<)IJG=MOsvch2Pf$i7HJw(L(6r-aIRz(3jf{EJtj-H#m@ovC{`{Wvjx z%DrqWX*eH1_oOf2NO0=N4U8*mO4W~&u$qugTi(Yq|r{Bfs4f&V$9g-MM$83Fg zyu^m3w9n`Q9}PxN+cU5Sav4!v#b`eKljaKm6(Hs zecV^Z?Mq)>&;!(T4aEmUx&&{>CvqHkv|jFu*R9=_9$$aYYiP%JNawCX6u(P-Fgbsy z2gt18<(x6I#mD1VS>~a3oX*rL`_cG)#C0KV{MSEFUI{(BbPK2EVZBb!KVZ|MAF6DB zl6)YXBIzVMxUMgMbv^UCiupSoQm{tCxp3-0xdCBbV^`C4>}*D)i9f8#61b*OC=&UM zxVZ49558#?itT&>AiXryXjC%4WXI=QiT%1u>q6z$YPPAG)ZSAKf8{d~4 z_4)Jo`>5a?f0G8}9VW-0dGbXs|3@0Fk#yXjf&U}vxE+1@o9;U|O3YsX@Bd)-fAQGM z4Grc`+e&Q6NI-?%P;&(ZknV?=IvptTp%(tS=CJ>&3xB%$JxC`m2+98mlP~qVty|)- z?5+Dj_imef*0yK6q>{;(HxY@li(&rc2v8|LB+c#A+JdxS&{dpGAqc4WNqrSw7F@(t%pdd@c=7Z^iA!HL+y+>tnBi~V)b{3;-CRZ#hm7XrOS<0%xGZ`6770(oMsCrc&g?XM{N$GNH9Z}C;Af<5Z=w&ot1_jt5>9~D#!oufE zgTost@0&wy+-*^4K=Vb^x=X!>Of410$JbIBnS^VtLOO|0Sjk*g%|)H66+h_fv1D7} z{Y~FL<2w48uWrsE_e+*;RamZ>-NTq0vuQXis6vu{sqo#-%pIvhdZuvhbZdZnvkra*wphVJf#J~PU_j~{nhzjp%#XMR-qh+OG{9%Mv93JM_I4>2R4=bmt?nW@lo;E%)6t#9$Z zo-f8Vj>>EQFfjX={z!-WP!Hyf3X>zysMGL6_V+(I_;#lQP_fcbxHj?^UIxptJhFes z7m?IutRD&bI?O5314CauZyrUFbdnuh*O$O?eKs@~JHMqDEb7N~i=qk*ypZ={`=#`? zEwPymCQ#e6h?esiaZN5XwQw0M8(#qFDFHDf5SXE7=32TCh)qHmTTIVTYoh`$0vCp!>Z_h^W-ozuLjY}5#kOE93e@!DYJZPkmDj6&Npy`BptV- zFNQW7R(gmrT*N!VLmvkeZt%|{I`BbN!>8f3-IEF#!GUt28ZRh-bU(z@=|GVWwG96{ zSS>Nx8b~|7w2m8I)be`x{Zi|V?=G~CsJi(V(z&bA-`;JjAjhA1`b8)HfHQpB1jc|Q z9q(9z9g>dQ(U-p$Bfm)agISS>!&+o~7`cGHd1L4)gWaIEo8cfMDK~1apa9bS5L2fE zMLyKRUynz<_v+#Xb)9yBbmD@fI{k7sv*O~hdE1@iM_;jjp&GQ6{c=Q~eiutU;uJNokXY?q(pvCuFo z0|&IMZ8m3vJz!dfe^3AtSMoZpYT@tqgbS9Y;!o&Ae_|Z?6>PWrrHRJ~yo?B%oDh?0V2Ntu2eY7)(l5j^0IC)a=KLLhb>!YGR&h4nACaX*@58q?S{{Nb$~%flwH ziy;+$VbT5m>*%StHcb!odfEI4`?({G9*dy|dJYV|Q@fI)N{m`flXQ|DT-O)9I|Yw@ z5u-POe;r96f93}yW$k7#dgxA6^h;*Q>qycaz3z(-6*W0}bAYi+%lV_jRNK zF0+-j{nz+za_Id)jmvz{+GD6#+wIB{WUE)8|uqKGo7q=x|D9j$?!i#dB1m3k?F_Y30L29+-zKeI`@vhM62=Br-E;C zp|C#{T}a1%P2%;Smn}Z3`&X{FYWCuC-h?NLJku>oq(ptJFdH3}6I!9neDd%i7i0fR zb5QS4zZeHJwq{<}@LBt~8TDc3sLV-cJgKNs76Gl>_oH6g<$5u}V+e(+yEb=9E5rpW zoOhdN+w52JCj83pEA$nAl)3877dK$IWO(n=uua&bgX^v@5g6*TD<*iO)z}C{nY=^Jyi`n$~j< z&NT?(oP!YAhYFA$Xo~Xaysjhb9f+jx<|Q?|BC%)T4B{H7{=mUc9JhUw&27%=vIi90 z&%?n7-Lo0~L;_Uh+=q0c!+r>jpRPye?B3NTUvORQdGLDDzmFd&+Aw(?3b0xD&xD^T!*8uJZvc%s# zRf!5e$W5}Xp)Wa%tZMLhKyukGvmHV&eff z?v^>)1se~vZocEvp`WK=_>}{r-b4F3cj;aXSw{JV2Tkf}>V(8yf9{ z>v){~n%NIHo*zi$mm|4JW=>L+br#tS40l;e-NF38G=2f$F3b=3@%m284}iV{ z_XFi_T)QDY{nO+Jpj6Uam}yeJR4pY(NA?5dypkv5h59S}fc$}`C^y;8zU#MQ6NNV~ zso53nhIjfbt^wQ+(C^CFPD<`YEBtGp?EkD!qsS`vBMkNf?2IdWQfvG!D1?lJlOAno zrjzUzBD$v|`hohs%a7~f2Y$ovd}^UkMrI?`d7*8G+ANOsDC#k72HpMkj9w9$H>z;7mzgjQ;?asQUz0|tmw&i0R@efX#`~Z|nnu|gK`Z&qa zk^R7=2_ro5Lj4tfK>k2el(C#2&}d##vnvMgn=4rsjQfG5DXbr$dUf3N#UgPHJ?Y1% z_6GX_^#w7_-)({)5XKE&d;#QsrS$O^L_hE~YoibY{6MPX0&#&;ofrBPb}umIfuH-V zI>(kYpSp(m^=CfkhM%{Q^8>BpcAeNC^|_gk`Z_Te$Np=!mo$N) z`-ShRID0~zjY`G?r}!MjM@71rxQI`i2lYH)T_J5ZGqC@}r8K`!0k?aS^v`sO3)HhpW4xKnm4{V;iB z!E`|jGJ*r=LUmO`0i^pOrcMWne5hrp?SH_=&H%Jh?P`e&l4=*r=kVcGj(N^`ENh%E z`qb;*D)!4;qMGkCqh&B!aFa{9g#Mv(>jcx#Ah7hFq~pku?C6SCd^cOk+eQaE1!U{x zG>J}m5EnMG)CBr?>~zClaiK1RCJK-d95@%M(?J2G`yr-I2a0^C1+Bv8!}FLNt%iet zeDiMcxb?jI9fOX%ecg>citb+1N6Mk~Us}_v;@T@c78Y*iFLA#7S$^l$Js~uglR^Rd zG|%Q6wtrG1*OOnWiXl=N;`QQjfR3wb=D;GBwop+TPrY zrclvO_H55mP{n$+QmZo#7k8oS@N0VGlRUl`YP*OYRqJG9gS}corZ8LwXBJ-9CD9oftj1 zp`}sff{i;B3!%$zE?dlC^wa|aO;jKwzS8(Woel~h-48K!I#A?8EnaUyV$+(spqJVl z9ll>&5K@QIfluUkclnfFwaV6S9CNHp@aG4g4kI0IXi4;@x62V|zNM2iWRnmGq~ZNU z=vR_-oG7qE(s4Wb5?E&OtWshE;ZDn|fwgK??-5Mf{p)(pU;^_BXQL)Dkdcst-B724 z0!a5mOq~uC`A`di2RlxGZz=-q_|iJIj0()@?wz~!vW$&_GM>-P&fIagbOx6>J5`Q9 zvj^0PKi~}KhBQtC9rtu#hos~7_2n=2md7SBfAFjUa6pUChm1-W{vabMH)^h+0Mh*s zQ>Oz(KGecr&1JW}O~s$!0dp+)cFAqaHunYZ+a%2Rr&CdM6yO0Hbf_cyhC?%fIuQt- zi$o4d|AGw{!465s?dVHjyM*&K#RP(5ia7Vh-RE`)efWEY(*_f$?WStTNJ@^HEGU3< zKg87OK#>o%5E$Xo(#hlm?ydf|!m_(Bo5l4ho1?l<+xzG!fWSp}Z#c>Mz&|+wqm-{! zP*ZCL(tbf#ah8NQ8$}~jw)2FpF{XJGh+hT(qDVU4r-V@;NyqKzOW?wH4@-&(gu&Uc zxBryS8Mc(3_wD*%g9%K_C=d$3H4*+_+GO}%bzBR99|}>Xf4S37l~vUnlg2e&e(~0) z(AbCE1Wen9y&- zWH5T@`Hn9|6FsDPO^jR`tp}@C06o8pCJBm<3VeD>;1A_L1(PhA}me(VNI66 zHH|`%+H=ik@dbeN(omymrMrcg7XD^<9c-ryf7rDL;fgv*7xHE{E^EBI1uQwr`?R>Hj=Cn}cJ<(D2wN~aapk8i})N>^1xLX4^ zNYZgT`eL|nsoO&FNdoWPfJw-;?fXwO7(?`I5$>aj4P*o<@O1yj-c`UyaeV&^R#GfT zaR~wXD{>G|fIu#e2A8(jkz61pMhu5Qi@UqKlMq~T6^fTaafd>&0)ZAQ6#g^2`}St% zc1|`)@85pz_>kFoGxJ8j^WHclKNCQ4BI?cyg1V*HF zc|;-*#()5TPg6W==LrHKBC^4fyD=dFQg^WB0s;q3DEE!65GY=(RiR`4L$wdMgwOH6 zT%)GbfHqwIYJT4+#16e2Prqc}{5G}nUo-X4W&nCDIz62N&|}eQKGs5S=IvRMJM91w z1=}W8xqp3@e)hiETWtb8NB|U^)XW9w{ngp4uFaw6QE+tw{}#HyRg)a+j~oB69hb|9 zkx5VFp!ZL1m=?zh(sBozx$-wY`NxM8>1l$UeW6NDcXjINX%k^Jk4dN37=%?pBmV`U z5U^=t!*su!J9d*&P1tOyS@L{D(P#WjC1~HTosI6onnT-LnX9JB=CUcTL}F^4x>38V|hA@9Na}^*v;3X!%14Qf3-&XO=(9 zou-R+=3PaKp#{>2h89RQ7M+F`i;tzyid#0_iG)_G>D5#InzC1fRsr{0o{FKx-BrQW zh1gqhHv9)75((Ug!C#(3tLdSZ5mrD8AO$AOpnx6B4`hb&J7|5eoh)HIb0R8?cem&J zf0;KL>Gx!6FylFzJm2diyMVBC(n;oIu z$%L?GOR5Q;)a{S@{XM9oOY2!N)gES*E;Jp}`9*_z*)QtL;mGxv|fJiepxo1e$@^5u;?^@Yw@>w*%((6f9;FaELA0Vqo!1YF^}ff zouZFuHtu7^_%pR<6C#3w;Y|asAOTW$uo?UTMcy=lzpbN-Ke0mefv7WUk_lnqPZWJM zZ*Qw!{@%T2JHDAYRE}yp^c2sP0A%PFY5;mHI{l&s@L|zuKGs5SS?B5{ z<)8--(EJf~;HgcZ2MHisvf(=ypy&AeF5AzQY*49(4Y)Zhc=i`Z@7)wQ&4*$Z`n5L@ge*GE$66RZdtY%0 z3By8yAcRNQUS2A$d{M#FW)+BtY_+5ygak<4!Ild!eBR|RB^O`k%J8q6kPmggDi>03 zciPx&!M)6m{*jOqOJ%WoTsc9g@Pefq^B`~lABX%iR&vgov834B;|nvb>k8@-`= zIEg=)6}cVTJpb+WQ}rM1{B)3FG3W$vArwp?K}2BZO#`kV0aACc8TmT{Z|XaGnO>2HF!z* z|8Oo~3|MAZhc0#mDxLrZq|wS@Yjm&r_gyw?Sacduz=uVr`B;m<&@Im^kO+Jj8(8S| zHybpd`^`&D&Q^>-Q>SGiA}MkV$btk&-N9z?2NZeJ1OhhuDZWX~$thksVdKw51CM6u{JqCl3i=rkW|5jZgJsAL`#L=#Ly z{=8{dl{`TpL?lIy0a=g$sXN#V{(vHHnn2*X=VQHXg+Oum_c$!_`LSMY12PiZ53bYg zepj3ee)tzSC%v3q0xFh(Fl=MthDE0(9q?h%X+GBCZ(?*;FH!=+s0;*9sK4g9V*KS~ z_y-AK;YyxPQ%&Hn(aN{QZG}Hk0(v!mw(ZW5lvcBRZmsF!b7c}vKS;pfc2ki}vOj6iGOw+A z7M;b1rdx}^f^Ui+B@wu>=9M3lnr+n&7hVECefNX%`y%k6b)m|H^#!r$RqObOG(r^^ zRdt@f1Rh?uz19*0QtJ)k7EczP&k+ANQ1{~?{6&_qWb0>D&BKK5kJbcb`b_w<_qo}p zxnPGseIPsh%hi`Y{`@(zUC9>XSWAHRm;e4-FM%iV`|DMzgrY?YTv_6$@F7H`kY?^)fuk)!fKb;!ex%HUNm*T&QDKdl${N{M%_i`%OKPd<7 zFaQ0wR%xTU#0Bss*}fV*3i|VS7k@QeQ*mYIMZNB%9XR~;`=yHI03Mw1KjVHIA_5;Qe^Pg_8S?`dscB+F zo1eG>I&v>MKd^*m7WQM*jkIqW%?fKt7|{{;s?nFsfcwwX3FmwbqR+0a_09 zXvxU|eK+CZz3HyC)r#c+aU|HEfF}3JkOShlA6D@hL!#0zv)7uJK??@mjCH% zmtawnMW?T0V(~GIa#3U^F0#1#qTUq}YH1%odi*RXMgy;d71JlrR}3vvDi%Z}6pCON z1R^9r>JB!8KcL8)CR8l1_hoH%O}(gMc`w&JSnK~)=&I13o-5bCdCKMDX|Ho@<)CF> z?O@Hzr39H!s}qe zSI&)9488KGM3k;}VyV7gqou7MtV??3mz;CHwT} zhP8;nbXe-Yd@^jg90Ki|-7FG*fHYc91ig|)rx68wSah0?wFtb>J1U4oAnZYdTRE?s zPVT1|fu^2@fQSH7ylFrdBtYs8HiJK)$eSkg&MKOsGi`;yYC>w&72i5vdAc;Ed3wd~ z%9UGQeHfG=FRHH~7-NNhJPY7d8l> z+LJ!tk|+3sh@`kN;0h8TbqAZlA5i2?6ZpIQ?VtHfiO6O*TLG)T6|eC0&_A7gamMPV)RE^Wk${-!2|;9H5+!uRx(hW`+Sw& zbJvQ_vB68G7Jm6O%w+?Y@EGSevhTy&hkq8SpKwJ5tsVlDSae#L0Us8f=3_1NPLA(T zgoGa4KmpocSdAJN6hp5p0Riz-_<)F{bOWRy0aACc8T*I=HSVnA;#$pR161{LA27izMsXN#V{(vHH znh=BKJe{&^B?iS=n6{f=7fD=}&|>kZj=?j2`$Mu0@xy{%XXFrQ9|Ky1Ku|boguob( zMW>Mld{}gvkF^La@x_$;q#%SbAOPTXrQyo=znDTGL?lIy0a=g$sXN#V{(vHHnm}M; zvGnh3g+Or(*sE3X(tW3lZ?z!6@6C&8Gr04Ks*6K*wzESo$I~zL^I-rz7M-3>0qC*l zG#_iB_rbUIH96?P>tHR<-Kdr)!p|J^AOS2$$z=#rG$&2@dod*}J^B0Wv8=fU%2!fKw;vtq((9+OV5 zF|ha)AdAApu1?4BZ+<7CC2Y3T!xKhp#y+~M7+R(_Ofzdkq%K~)9i-nkuRGx9rfYc@PqBOTN^Z<#XVK6O3f})LQbmvlhE=f zvtj&guKZcGwl1rLbNlg<5p z=OV?>`bex3v9}T_5RpjWJ`Dcy99mD-9-3nXv;aC_exS}Eh;%YTW}hc}7yRY6C8Pgp zIc1K^;>0a)j&Xs94S6JcL7IK6X3p~?Zx{Hm=sA5J zsaxmPqe$rW37FgY)Xc5o^GH)h`tMc@JyUzeAR@A*lDjtZ{CT7@7qiw{0X=}4S(D6= z+5352Guvcrs`^EntzB2R4Lv#d3KzKKpyW$(Qq4Y5X%Y11JH4%Rb4I$+8!Z4O`c6Th z(|4T#9~PbFW9?WiG5`3>B=jnl9Cuaw$5!!;mN#ixad`qgh=^>dB=qw9Zo;+4JG$8l zdg4UouitD5ZQ1;_{%7M)fsfe(vL^RX6xL%ThEN8%5L zX7EJH!x7V!ub6XNU%94cj2DPViW`GJNPyHGYzBWokvC1?Z}a8l|;QSpa&46MOKkZB|ChRKi%k!7NFB_u>cxk^HBd;c{*`=Qqg;fWOWxZ?piNMilU2(P{qHB2a&K-wP6fAC~WEvEl3%@r{-vKPUW8F#=5;8G?wU$T1)* z&y~-#n8CGej=)v>9kZ7H@FHMJ_+S2={r7R}pn$;tjYvq6Q$Ov)KZ_6uvWr$50Z}YE zjVR#5qSJh=MPSsy36gnG5KS-*`C((@qIrTqh=_$iNPyHGYzCwPMcyTD#We#oYp@ z^>JG@!SPuaoPLmiH#Onwbh8c)xQH(D0( zD}nlG$=%i}70?~1Tcnc*{?TLocjAtW1cB6ggSgLyMdvfb|22DSnKo{Ga@3%A zfzwm_1bCE4_<;*{WN%=Y9Q1PaZvJL%Yd;$uI-0cv_>bMmOcobzE8=-|5cO~EcQO-Y z#EnuUTSdb(XWQTJ6uz^EXu^fkVB$XE2YyqK{zu6xCfWW+JAa#SY|c8p3w1aDLw>W6 zzJa9w%Jv6(ed=z0psVS-`M2#E)0ymGa&#xNd@L#z&<{&;$G(#}Qnz$Gov44soy_tX z&Gx^LJjTbpWx7%IvZ`J6cuhnmSpxK(%)a}!KMnuvp#H&@r7I_A>6_Hw7BN||9Ka2b z|B0d(2r3~WjY!}=%!zjJZMi?@8!avO_Di%x4p93Y>4h*+F2I5rBoUit-)MP0E6gG3 z=#5r;cK-ITR%DwvF7OwAmFnAC4%pvl`ER|^Qcsuz?J3bev;B*lj;d7b#9GZ8N)8kf zRxOTDascRuDLDZ2A89$T>+p!-WQUU@IUpYk8oUUp?Ip<_TMkq$`1il_tuFbDX8TuI zJv)8rqiq_xdRf)3`sq;0OR`#MIdFCG^1DSEP17{}>{Y9G1!o+XbKvPp#d5&ZQ4@%W z>^8}rfl@kc%LO@b;*(XItdIkA|If6ONj1AE*WWd?(oYk$Ek>qPzZKA^QX&_)!WWxl zZ!!K)jtA^-w4gd?HD_b>N$GgNo0kK6t>hIGbkc{H1Nwf{8!b+J&#HfRa^uNaJ*MjU zR-Nr%LZJT<@x$)NJ&oxv-dtT7sx{D6XSN>tKz2Aek^_(`X)G!g(0fU8$Cd*HllP|4 ziTYQJ2jnxF?eD_N0i)_=RlDlw-z#d7B|ysohasFC(038uXz}+{Z&xe_h;vc?d_yw) zWypan@R8?lw3LWY{jER_80r7?cmXniO|wT1KPvR|wf&zD2%NY)xbLdxOZh9Xepsk<01jproVIjdw|Nbx~>Sj?ao4PlXyMW+`zfDemK^RaeH z_VZ;ASCUYKMG;sNth)8%?uwz8lXFp!0H|!KDXlW88)-AKD3Xz0sJ8;>F;y?Qp}1KU zZ1d5B`M*8gEnstl--2qC3V6n)edWOy7v-SW#{N7K^-Ny)qJ3BJGkMd6I_I88f*m&W zwJ)$AfJLXTgJJP0KsGSR>}VIwv1^{Mu17{{@*zJR51p$|LhH{NVUrKF87DrER5h`8 zRmIRUHM)U_$aIowUYFvpwDbanl0~QQwg5gXI?cyg=!M_ET#AGqD3owHZpEUPl}kNS zm!d&LWJ@Kb9wb2O4z^rSDAQLJw%IPX>Owx$`LtDwJ9Zlqw0HG|i!&}(`UTTrmrdB& zf%W7NXy0dQ(LOgo8m%XSUdf`QXXGx!6FylG-cSLs0ZDNBSO4Am?($%L?mbkzh;>Y!qYUgateY&mtw z^P~ZTn%u>7exK=w)3;a2;mi|EL6f-0rW9w!)t%0i(YgGIZj^zTs&Fm*3sKIBF6u4Um9wgXZtD zBT(_ACP*$8a#(cw9yQ>@qSJh=Mc{#@F&-oWK`_DVM76Ka9i|w8B}I4{ODu>;^um1@ z{6PYw?qDH)m$+vbr-{>@iB>Z&YHW+3iQ3YfG8H7)+u2W$fDDHtVLkKYuPhM1j679UMI@x zUZ<~O1m*u zUH5EkXrSb(@)lRuhpaVy^XHMyU5b8a3I3=x26085MJGD~vzM)1tXZJv_wD}* z+~GdM=lrXO;W#j-d~zT}&m( zNCQ4BI?cyg1isu9@&zdfVGIZW_~gvdx_N>?h=^>kCd8 zMSn$Yum(OXI?cygg|V6E^EaeagSq@wCttT3dS$NOIr6mf6?1M5oQITAF9#8kEtMRr zK?0=iU=w>sATUf5vn2&Xqiwcpvzm}xb>ie{%Nq6f58Zq(v1xF;s?p2Hk<;{r9;S~`Ec);DTx}Mj1o_Umw6EA^b z#K=C|Ihrb4Yd44Ix`Y9!p+{XeFFiaD&f=$-ixhM@gtmzff zJT-$Kq8C0o&{(-vKb^IsevN{#X)U)U;J~Z80Y1q*FeN7UEDMuSeWtGX)CkxkQAGtE= zgJKxsot&(lWJ!EP8r<;EWXwN*U3U2!VM{ELhSZKRao&?f=QG6rWu0OdVc2ukk1gNb z-4rx__~!7%SAT7egBALq>Mkm!%X?HkBL_qKPBM$;Mp;q}q#-TcfKHF~fDemK^RX6& zO;a=cNf?5Vf@d3U)Ld0xF$_&zkpvNut(Ke{g#<|5!Df(}K#@01D5VR&4YJwXsJN3X zf6R`AYF7uf*f7qe-JFci+;A>nCt2ywS}c`ApnZ16A_M}WXnhfec`Q1ODB#1Q(|oK& z;0Yi1Uq}Q#Id|{KvD@jQKKiTM{2vt~(A0T8h)9YY1G4g5A59E-vBwfY2zxXwHOUN_ z)ki1nc~mmw>7{^eGhWP@xxGg<4uRzCj92oFhH@~p3qp%v2ymm}6Iy&rLZ8apjh+w$ zIxX;k4~tIow-$!mzx_rsEG!fEbhN|vbnywniVvff=LrlUBC^%~qk^#ftEW9}1w&B~ zt}k|@&Xo?M!&Vn+-`Ta)7=Bo&`p`>-=123@m^Z|ZK*bX?Ai!A2VbSU5a)A$vPV=!A zf#q*>J|`y#;T2oAau2F0MqmjMUIqaNBy)lg5&-_CrZGRMJJ?L9qCdO+ZnGEUMFd_5 z9~D}vVBercFC*GLZxHwhryEpJul>`e%OTLNidrNCVGu{Z@eYV$(P`BZ_^{|SA8Qfl zy5o2-i9i^m!4vLFHh;HTF#>Zk7=#1>mZWAbAkeqdvwpUcf#RHuL-DYPR(FfH9vOK4 z{uI^oD;xqzRdj=PjjtVsiUr{oernW6uF# zl2fDKwpe>U&tYh0g~DH$-lkV5_Vabe>=M%$?lfJrS5XIdd|UmEKMsfE`yzoW&?$$HEg|A3zH6ZtTPO0~C-$NUc;XKGk<79W~!Eew}*{k1p= z!_}4U`A3(@)Ku&HbIIEsXX_ni-@KP27z$MgRhGpUgG#klh={jmLsbj@(B>^60pMS1 zGOJ$d4ZV!Qe8_D{_L3M&q#?BuAubTI=wu4ao^`*KF!`m{d3nID{_l35t5A3m4lFtA zKJ?lZl^hK16EhYmr69#v$|Q?UOE=)dqSJh=g<)9smhVUyf{=pgN%fY`cPfUVsT)5b zBC^$z6ElzisXN$m0fs;R`NMaXz|hipQSb*z#3pNgR2&w13_iSV@Y=m$YkxoAb4rz= zcW@vW7G5h|AyE#2_F|ifKe5 z5Qc@N8jN`~x9$}EUmar3=LrHKBEDGQuK`(*0C16-27gjIZ8ISVOWfP(Ybykb`smJM z-6sBabxrWxqg#Sj$KB1u>6h%7xjHf5VL2Guk1<&UL*ab~O=;?>OFjS4Gm}1q+F=8H zSah1dwJ_|o_xLUnhE+~4HAAoOu}Jwb3jFQ^|1*XSLmOu6bi9gT}VR_)gxZ3fG#UR{lLMoVm4~Pit zylKD{BtYs8HiJK)$eSkc_f4r^*V+nyq8NPGWlqhIX2+Tz$n5s0-sJkbaV{h~*3O5P zT4RTy;%S*%!n929OE)6QESaK*R^m6(q4}rZZ`ZKs^!N_=u;?@&YhidVdG#$4hS83l zp4BO~T{CNT`q>fROx3H0^$t-C!?GyXtYZ%l5flvV4-x?GVAB48E^nHEVZ%|=;w^!p zrKbqNADIx=X+jZ(0mafKFzbMzb${efc? zEINx1O}7??8}^it+(QV*D4I3s^z2mA>H3DRdZj9cp{d6J%^joYE+ha7NNSp^dhl&R z8WwB)I>HhdQi~C}dyJw*p@Hx9$G&X7`R(}1P3CWZhtn;A;i}Kpj*x?4{z7~f`%@1C zZov%z{obO7U*Rc$#z~(SbnkGw`Fihy?we9K-!1K2DiuEr>sf&JYuH)A+o`|VSvPxM ztN8VyXMW%ywVSI85pED%FhzPAPcU(N6D-M)xw=U`ce~+5opCr({>%Ge9YX_I?78M7T!wGvYa4(79zs2Ej0)^@loUmbeBDp3Yxs5GMbGH5cPT@Oyh$bW+ zOdMZpe(S7W=M*4t!}KaWFlg?bFukg6Qr+3(&t+knx?s7XbfR7g5s~eURjmgFzmjUr zY1@Og1}3yQFfo590BJ_E{Tl|>Db>nzyHWMBs$Dg-_05K43Ao>?K9aP5@$`>A2fEGI zf4=bRvHjMs)Sp#f-mh3D@Kav6%#0hlD<6>tyBdB5boLPvU~nV9jQNqShHn!x!Dm$F zC`)7ltb_@sC=*z8L*y#e#F5>(D^$o5#`mpM7d)xAJT9=P_>=LP@o$esRSf>4Hl}kj z0c~aOU;4XlwiXBe((WH^yx_%yu)ly=4QYG^jofKEZRdjF{!-jJViyMpJy~425Py`4 z1ApNp#Q=#)n(eRV#ertr`p;6!?V2Wvg9^g6H8&-yZMHwqZxmSVescw=yaxL9J>?I0 z5OmcaMI9tZCUPVWAa-diXn|Tt?LbNH*y14j#)*6+G;yN-72-fXquKuTcyXYitCv;n zDyLO0L&y@K#X%jRmtOzb<^3{&5t*$H!#MQd@Fi+<)Ni$v+nd#C>zs*85v?JReZo+jr{A`TQUoxp~H z_Wj9u4#R#r7JV-@(*S%}befN~bGC(!mg`8i57_3`=cZrX2QB94Lq4fdQ85Bdo$r8% zq*W(YjS3PVbqAZlA5i2?6AD>+)pv3 zx8?;73<_Dj!80G(5tw5H(#U~DN*3LP8r%T_S#+9@wFq2t{c9IF1fCjE)u;H!bM@u^ z?7T}c0--0Cn;|oYKu7@Dpbg)-fWQJ3zdT}d1P(YoZ?WHoOF=7oEQ@SApw>bTfx=<` za&>fWatO3jrwa|l38MgzM$0I;K7&Q45e0l$befN~2)wcD$s!Vga0VYl(237~ zeX1CNrcQN0LPhbcUN#SFF7bHOH4mN{7pvaphV0fjaS9@E*u)2_1b?>f!|JirO={7qj7AUp9 zTlK-14u`AGl?(8(BT%s_3IdFU92R|oWE#vMP+4@EkF^MNb@^g4i9nD~KGjq~9!KZu z3!WbrpcsMNiW}G1j1dD732jj@4E`ViQg^T!`~gMYG=acN=Bx#}}T| z|LQ=;RXCS09dmN;PA548+6RLcX`yf;iq;YVQ7k$w(|`|)PV=!AfhYR>_Lf8-9C!jH zu6rBjxk~&A{MeB0aACc8S?`dscAw6t|+Y2*$RQ;U@&p<=J6kQ-PLMy z^x-S@PPaRaQ!g0|c4+Nz+vYIj*Dp?sn^*;VuJ2mPy9;kVP=XLHyy-)&SHOigEINx1 zO}7??2cJ}$M8Xg*yiq?N(_lxDh5DVHS~STK45=#10+^V)@TRAm> zE&joXkVU6Qc%Z+s=rkW|5jeMxPjgZb!iaG0@}|NN_^JM>A^EGN*5Pz&)jb*~nAoZ6vh(OGj;fE+wvI~>1l%9zdU#QsiOwlaZ}(X)bYkv(7E3dTkq^A8kHVlx!=7? zc*xC6eRs)Dylns4Yp!j|9=%!Ll{(S*-JwsW7kApB|C2h=_^m*HL7iv>`b+vm=AOTW$uo)v7T%@LnAau3tn(Z2x8|>`Sq=I4?np&%dh{#q;!VnT5bq8B6 zz;H;o=Pg^oP#hOkE>UFY_7)K#6Sf?6oIbIAOPoItgjHLNt|W&*yCAek5CYO@E(M7oY~3btqaB8dr|3a|vEaj^)7v9~4~tIo zu@;6!n=O-^>jn7)yB3%3&%p^E!x>2fya09(5!iXt;13cYbqAZlA5i2?6Z+_e>bhu~ z!*Ex{g2zv^X%@P4e7Qv-H`}hkxsbrHPsb`{ z)xy``*T%Gd)vP#9Kj@=j;nxS*5vW)YHs@E$jPy=G6s<=Bofd4shefCPSc|~7E}zsS z5!mEKSiQ!DGR29R#hdQFQH;RyA|Q+f7epj_;XVxh@?0Oirr%}JN*QYchD9ec#G059 z5%}elaW%I6_Aq$j%xaOv>;7>92L=S5`}@^*atO@T5uus2YIr>EU$|{@NSh5FWtQ&H zIGmB59{_qZwQaJ~t`(`*e%hg7(OGqP5MopzsM39NUceWQ=lw5WDuKXw@tq5yd|a8 z()!_}s^7ie=~2gFIFLjYO`kaKn>>dhj+Om0^osI+l)8)I(s;h2owMS0BQ99ySP-&Q zNEV$IY#<0(befN~FpTgT*`9StU?}RN7o8_GoiMv=>y0&!j9lP3_y*1&=%a@lsTf(X;&V9!f*iW_^TqyoA_&bP5E1~GlbX4Jz@@>H_uCwS z{ijzAi5Sy1Y^Sd3NY%(Ur%43XTDNwg90GH7@8qV@L#nNOK8Ce-(tiE-f9o}fzQPWo zk&><3+5SJ)_06}X?H0{c>b}=NVPfl{WD9t zpfRqH+EJ3+vG-2Cc-uOWPSn3*@1%T2v;8|A9kqM(*c}?WdRf)3dOE9vnu{|?)fdGcq3VZxCZO<%h&MOegHzA^8MjNRSEcS^ zxHKt0I9dW!G#l)J^U|uT)vSyN;@HCf0rGaa^)WlXyh_a58ioG zWG*F(Hl^-jxHL!13sw0mtX-m?1N_JB?7BcC+u7=N8~Rik^n1$*kIys?ts6gf;@i}A zxSg#L{9fS}5k?_tfNoStMDuif;T7iRGzM;WT-0zh8-{AXUt)$fXIh!v71&Ihvv2h;a2l z5y?bcSOY`{2Ni0Q?*x{ZivM@wes_gjNDB^kleq6{g8sXy>Z`nPSj3|(Hqj4w@HSLD z$gMJO5!#4g;S9d`n$Q2J3~qCdD9zY(L;rCWE>-=>35V~9zVT1W8>P!i-iW=JX3YQn zsZK69zRfib)x{>}*AqvAe%QdpzZrcvAbK%OL_de1__(C_7;VzV6$!2w)O06~vLQ>I zCNRcK#GkxZ9Ip;Z5;bDp41LS{`e&)Q-rJ*8^--m8(kcy92 zdC#Q<2oZG?}Sehxf=i37;}L^`f${DZz&5<`9D z&}HqMQ`iHk8XvFl$v#Xobh;>M({FhOzq&DQJtmW$6Vr$nu3GgRzj#XJV$GJt&TTMa zeAH&_877(DzDzqdg4=A4sr)Y?P34@c)4bzD0wZ2`_G1lkjZSUy1qFA<5PcY=P+}U6 z_ejWwC!5lEdUhVXJ9=@)FI7vs?b7#`jLuXlpgU6Ipo}Ufv{!rW(zEC+J~SP-oP-%k zD?08-(Y#iD(KWr}K+T;kPaU>D8?1?`a(-8d>BBUe?(W!DxLleBcO6eJO_XdzUvhdx z;n1&k>4Sv>x;M9stD$&QQ3*vLRGHDD=OR8L4f2A1HaMW`|8{sKjOK293b;=>>G2ry6pf*$o`o{ z7@;u8abblQ>1li@(au?M>6gS`SciSUk)#i)TC~veck3%xnmg<=+W1rBx7+j5PVZ#W z=?y->hefBSf2~E}vaUlUlywF4F+;;R7u8ma;k04`F~;7>}YZ6>xIEG+e~x~*VX zT}Y?;S!J!hXyT9-TN<7zb*RVQSWE|1bnx7%8FC1;3qp$oAq!FQWuKRN(%)DR0-Y9k zz=uVrk!dXgf4Ww^Ac?>xsUDw=D{K&i`!+7GnD9{?Te5}@m=xcj7N$!C;lzFCTfCqmROHj@~y1uwv0^ z{Sx@F=rkW|VVHGc;dT;+Fj|8HQD4`25Uv=8IT;p00-!NSO=*=$-AJ1W7^XZfvcXm` z6!lT(=ks^(KIap*+hgIu?NxOXaoRy2t$A|lAv*#U3&IQh)Tq$}3?PcuBY{o}HsHge z(|oK&;Ea9)B)8cg-(30GuX7Fh=rf;3$}g*`AcDadF%XgHh5Io0%X57+uxjOzHb>x` zMQu8(I&W*S`1SW+w&}Ij0~Z1y@bg8@cgZ2pJ|eVeLizGs_4Kc!F%OkXjerof*}Yt`ltq|qAWVCS^^&yo#taL4AW#^( zGhM4Dhc9}qn(8s(}n!_|63cUi<6Z*EUy0FJG#6E%5hRfxD7EJZ?Tay()>ol#%P^ z${{enum`R`bz$QcT=(er7VWu&i~1TTeO}PL!|CShy$iZ;O5J?7v~#IcyeHGM0PnX{ zf!|$c$G;xV+$UqdM*G_F9-0j`9VWEtsM9>GR{X($*8Mbi`+zr|H9|kKxGR+0+M`{O zvn8|MtDL@eaLH~_aZov2-0yj>s*-qP3=W6)+6mPqIAMd;s*SfBaZTW{$I#_>!Za$u zJlp<$r|_LUG+_Rj(VsiV0w#_xm0y|Bca~fKg5~{93C1F?Ef0 z8-f0Wx<(u5Pw8v4e_ptK8Y$^<362-CPL?1`y=f=-b;2bGsglNGpm&nwj^9DqtMtI2 zxp%_!sf@#j4hWf?r9s;;NPYEU#9KN@#0fLYo5<^M?YE zW;ENscZ;~pGvjv}RWGaBRipkoyqYWl`Y6bUk4C-j_xVbFd*K@G_dCvvR4fjPip64F zA`kh9G@=*o!_e^a{2J}wJMKTOKpcphwkU;6q>~vkdyV!HkHz`gRT$VN9TT)`LIa;Q6`wC9#lf7+|5cC^2lkVJ z__QECiTIyA8R%58XCvK%o%WM~2oLs?fzYD}!%?srOkt>RAfPWegU1tHG@NNTXe2%0 z#(T>7Uqb80X|kUT#8qafHdH+5(1`tHASx95$-sZ($-oc&9?dm-GO)|h(FL17YZx-! zZRY)z1!`pCZUu(8ufM$^`*5I-01`ao3B6g4PVj8w&%|lyosK}K*R>La4b3b%iw{jF zr~EYcHCK*ai`6)D<}i)(mW0SIQDX%AWDTC@Y29tnZBidkL}x53;u1qYwZpR--T@z{ zwb}1pYM-l1$4eZw>DGg8a%y3&7a?oUHY{+^duM=7FJu587MZ%oY_T_CKMrW=ZkRI@^@b|i*Q4We6HoTpJ~27Jh@!|8PAS! zMVR2OO^_?XT-`+zSgBZ4ySDSV2R^u1C4a=rZvBAFcOv2?x&A<>%rxFkC@VaHri=C} z+zX&@IDR;eoF6beFHBtIr|vZddOzx3W9YV6bQT|)jvIzGM|}0p-;W|2#zNubt($PK zae=RHtW!KafcrVB%CZoN`z@9p@%5MbQ>pU&UgPYgkDFs{&B`Ob;xqtt#8;$42C-@O zUgPf90?WjEKMY+n_s{BAPnQ^t14(w#wEbycfE*0l2||>Xr}+i?TeM^aD~PNoYmW=- z98SV&B#vD889@i=V*P>7kKhBF+%i@djkE9c_L(=enqD4D(yw0Xqghseqf^0OVl|c1 zy3DBbTYpWfA(795ZVceo;6@7J$pl|Hdm%jR!7nAV?(%DJe=dAb1Fyj~7yLTGk~%HS zfle=}3*p2B;*8(h@JlAy^079Oqr}jW!Ui~+PL~o+jCNuA$GMUiR-{0uw*k>rg%fkQ z`LLq7nix9LJMjY=kLk5bL(}Q@f)kTeqQZw8i?Kjdc(KN%06mrd9V@Tk(W5=#%#E-v;!mCt8zx^>xu5-zC zO%tRZt=^;yN<52BLkIY<=rkXRnk1~T-xSm%4QKD8;qCo7O|y^F z!*(WK(N!vwHJmHLz`&vNdJXBXM{4 zhKm7JG-R939`9~gVHNyShFN!iDu7@WWk4F=V})tn32RMsIv{fxyp^kpa*V1tDkOuf z3fA6*>4IM;EM8f~0OKP%yDq||5_IuEpG?yQ5za+PEBAa=@JfBAb05hQ;u64zOej~X zalRvg^J}%w7w4PYhvTMxv*&NQBKidPC+J7F*28#<1^SUi#L_0F3Vylm9egnOE4Cyc z2&Qq%6w<-DKTjKU$$3S4O}F-MZXX*vl+zXz!3PFo^!Rk%_JYHA&iaJgx=gN2@u|zs zlDboA$5+B|Kcmdi^fZ0F>J`4(6Q*e)+-lJAqt)@LeP-+V@F?cSyITh*?$qq0_PjI` z{5x0lNiY8E9MM07i>KfN1%?Z;R?R5M(|I|XYk>sP1^84*I4!Me3Jsp713>8Rn^iEl z`-V*UX8bySyk9>}%+N&x9A_kHHVs&R-fiL_v31}~?`inEGudZcfA*;ZX_o+`tYZZ@rOcPK>P3!0~scNX_ zvUb!v0v5xmQLjjcsIkeq*h;)jAo#c7>JICsH(%dWo8Ythz-b()&<7{OEV9p~@kQn2 zRIW}w;aJ%}b7ig6T@07T$1U19D{c=Z@mG%e>(joMgP&L3V|0k})z7yaYCql0q|=HE z@L|zud0;IJ9Xui=mwFs>tx@j#(YwUkt@aJRJxMVP%W?&Z|454%Qy?PzZTK1d<@q5> zb@#HPEP)}w&QjBm8I_8)H${ZupOMd8M(o|B*;MuI{`%`9v^cP2@~OnJp|Tpa9fquN zLb^}^P8bRRH(K4P68+#{&#c`>w_5?7h86H((P{qH!tlkM$SR~Xd~~GF**BebY2f@u z(5=8Y#V|B=yA?zv6q;ZdULt=}^Su^V?9%XoP`hu5nG=g($bwan!?PiCrW#8_pwm(h_^{|SJgtS{qpN#- zNEnvXx=(lg)F2IuJlgnWp1=?ylETLTuRNEAPDc`U+8l-hP7H73q^a3*L(QHIJer&s ziAzHw4Zp1DFvAW*#V`aZ#)1!vPS1`39~PbFV=W9T=Koo;`T;@;ZkU=7S6i zB+zN;27Fj_nvbx?&hs5K&<)y&xjd3-@90m*+}p zmqWW+*&K#Nzt~>VFSvi`YNxp=@ly}o!i69i8~!gW^g^D)(9D7b?A`hoZqvK=e3(`j zzDHA#+NKBeSZbTzt}jwo)gQh`!=khJ&~$5I_+nYaBNB!yiq~m5Z|ok8hp9spK ztVoNHX1hA>NUh)dEA9ev$=I-9^3!*D4ns1@#@~jn(bx@Bl)8)I(s;h2owMS0lk)`& zkYX%ll0~Pb8}MP#X+GA%a8Z%SJ0uK2NWnzq(HaFSD~6$|JLe!Gz6#*4p(-E&;372* z{-ku;Wa6Bt57WUD26R!D%< z9c;M(!+Yt?mf0MJProdXS!&>mu&>wpX8Acjn2GZzQA#UUX!5-shB<~IEv*2CEIKXq z0ER3&&Bt08&ae3@Ne+e}j2!yEq{G`DQ=4Lkg?Q{RB+vi&Fi>CV4lD(?g z{;j_adh@<}x;}uqeXb_I*Fk@Wx_z#OK)*}fJ_q#Q=-cPwdmNoYb~bo})OZ2dZ!K67 zZYTKVwkJcXq_L<}KyM|<9s9bWxi=>7p%e8|CQ<+IZl9CSXtuw%S8SCbYj+z}FRR*B zC#DCSBTIn3ZfNbb5y$q=TB~m@+&(wzi`#!HmItelx{?n%(uw+4$OQR}X8Z4o>HOPy?>!p2dRf)3Dq6i@ zRk8$VnXs`{`)yh}Kv& zOrX0VdJyM73H^;hu1TEhFvK78bLPw>mAlGA4Dlbnhwe^+9xID|w8wrA9cp6sd+0F! z@DG5;+lap$LJ2$mwBJL=6$mafd|hw5@-1@Y@CM1T!EJ+&EqI3Rj4 z^o@TGLGf`(@iE$@jVlsd9T9=<#8Eb6srGy5{*Cw0=>{)LVckO~4t8&xYCUP;?C8+Z zySsU3Kigatw-d==_r&_jHRTkWTs^;Z$Ybe1-POj-2~fUa{~J&9YUVsEzVOmseXL}h zrcwdDAT=VY`2In=NXLD87M;b1rdzuX;d68RU*veBP{!idCrj;<`ctPs7)~9+!Bip z?67I}H1E^+-mYt}l-F!NdF1Afo#8*=K!p~lK8SZhUOIZQP@cmO$IAYhTk}!sE{03v z;}-3l6<0w?{FS5Ayt?{tj-Ot?*J!Kg#2;1T3lC<~=`EqahefBC39W^pXXWBqBn&_Q zG;qlZr#<3n-XEKs{y{MeO>K^Wh`2Hr{}`$w&$o&WJo~7wB`{6C!Ro@x68Tdr8cRc<(^3!ku;?^At%c#im-7~oFkIcaU3sVU-J&%7pqaEUPhbcU zNvl?@8daW4!()ZF*0i}aJY6}nRr`sfLU+1+C|_w;(K@&^B+^hHzjB3L8s=CUvf#s_ z)2DVp8nWm#A8TRw$K`<<5{4k8;4p3XS2Y_ch9O+AOG-I_9Yh3n-Za1v5+HR4o53GY z#?Gc=%f2+ievNx0)E0nN&1AI1=YV0>fKXyFIYOP%#W)Oh@mu23WD^ zw2}#YSah0?wJ@wZ^NHl`P#ChoVcOQ8yC|Qc$;sFd62O9&Je{VRfT8a2jNLYe;jh|X z`jo44rbX7vf?tPJ+!cb;FHuV0>+8(0!%#5{{rQmAbL2 zb?A~$Ca(P9yHbO3DM(-#RC#RPOG7gY7XRYYy#4Plx*vRLujV7_G%wKOsnfhI+s>|A z+;N|VMQ8D$>DI!q{q^}NBn-U^G(R(-)IN=uaGLk-!cX7i2!_H!gwcY9uMiQyPwMX< zcy!}=NX!*WU`Q=Yh#Q|+bUs7;U$duqGw(ki>l^>P*`5be+t(|yG!qAtD5Z-hy=i2Z zhB=moEM<~Kr==T6Ll&LpV=W9HeS zIExk&O6in+uWwiaL)O9si!R2EKFlsyv>MgFhhP5a@LB3AJAUbK`5q1|f#Ii1*7dZ* zP%#Wa$)r!)!q|{Sr^kB0hefCPSPR1@tM{HIr6G(B;V|uxnwx9n2@D}3velAPIgkLU zJJ@mohF7X@IAL=bp18B3>#+Zo4qDQ*@DxpSn_qGMBuZ)4thux7Fw8LwX=w#8WYKA< z2QXyOX+GA%a8r>5N9AA$!f4jjRnazqAtV5RCpB{chO3Tt=xB2oE~$7Bi6C$~-=IdE~vh7I}_!fD>A zPd6=7EE8aBH>q+#-@ccRNCS4>H0-?0^V7Urns)bAAQQx$mDC7Hq>~vkdzyFb#uX7i z&HA#{#`&9Wyq;fd4-PC*&5rNr`OpwoLwtvgsDX}}h-K(LimsRa5-HLDWktIOOgkOB7edTdK_sn)iRxYuWypf)2Z8FYdY_p;emO*&Zc&x*x^m zAdw0Ax&(KYlL_|Iy!eE#8#>?HTji{ZL??ss3F07CUv!o@Le&q^6VPekM08Sk7_=>> zX=rrvUX;3v;nHZn{7MZ_k-z18?^V&>z4P_$q~AkF_VB;tars8-z`uspc|3iu{WLEs zC;Mq$Xe`pE15{)dAim+#ewvpn30!9Qs45hZOc~lw^YTSxKh10TVPt%YyFHROeN-vj z-4lt(E=R*7PdI9Un;!n3uSg-seEACe8&C62`u6dAv!{8N`HXiBdo(y;LBNoS%a#}L zMOmg4oBG|NXvO9O`eBdwht35%f&NI+(e^+mT^R2tEluUj9i2zkuIkUrHfT{rlhvc~ z*yPHUDvd&J@LHXScYMD7+X-c+RbH_8UW4rk4MwU|&P4@gT<3tk{RYOyG%fbAqhF#f zE>f4Mj);#-*2N{OW3_SGKFA&!ACVG^2-uIKpWw<_9Q|~0snLn?ah$VkB@O_8l{a% zLN#Q|?dK@O6oZAud(aUSeXRlTcx(lTs2eYlz&@FFG~>)s$RByoUlJs(G3$J4e!oIyx>@CtpZh@$!5GUr-XLxeQRJ#A%a~qWi?548>|u{L!cmC1uT{ zj_FszEY;II6Vi_)aNp?2NL?I*fzY(LWY8WZToQFrI#e?eItv)d_~m)|HIP(>AA(%6 zS{D_CIz20_sLYVhk!&u}hKXBXry-6!3+fystJc zP8S1B!qE>w1b`s)R!u#+A}aXSRLr*fx32YPj{~nw;)ds4>!LCn7fbyM?d3^v8gr%^#a=D z=m-Q1)NMjy8_1{DPZ!%8H7X2e+|i-})g`Ip<7C>FyhmW4lB82dMkn`0O*5{KB(%^b zBpx6X9Ri9gDkgpqN>s8gI<7bBef%1T9wDUAdm%Zej*3r2D36L!YvVB7qY{PaF~(h* zS|%?|v9lyf`64sL6@>uCxM;XGmyj4Af%;T+A8l-`R#J#OyyZOt8!{9sKy9*1Q}_Dr zuH4Vl$J^J#$K9_1=Lte!ele(9)F!G2#3%Mcfd(*QrF`)Wkd)_i84(hGNhxBcbaC3= zF*>z21~Jt|%CMDsfFuc2ss##dNOT0>NO?-p#&Bv(VmxX9%*ftBpk6xkxt-Li>P_k=j8q(S72=(v<*9S9MWAeW}zt_WyUG=ewaG6=O5Ajyczf4x=;hha+Y9~ka1+A|o`FGp?<8F!lILoisKH38P+U;K7epE{NxD5$K@}3Ifr{xA~Rmi-(8d_G(fSSj8VF88 z8Xf%xvAqgTqE{pr`U#aw79A!-mK(?<*AKxC2?uKmf}I0j%X5IdD#?LSYEj#xTAW{> z#P}4Xe{iEt$hw)T6|{9U8;}$&_Cb;%k<i~oU5e|GnNIougOnij2QA6*+C53Z_5Q(}3oi^Dx1dn3E zl@EaQFS?narbNzxh^2*e!GWl)N+xC^;$wRwbuE$~sTlHa?AH(KgyH~Xt{%8CeG`|& zh*))RZBldu8Wr(FOBZKhu)vR+)zOhnTp9{LH8!a~;O63tXM>P-!-a73_G;)J?B$E5 zj@(1lo~~|aI1}m>qV@>%_3`mUlU9Llfi8SPa0Gz?UT#51(yQ@@n*0J6S63J3=(wb0 zEgm=GAnsnCL7whD0cua*AoM3N$Xo5}=H;ahaCZ$34e|7L4fXUTg5WWB6PF-vn#9F9 zE*_~rOP^bC|L_F0Y zP@Vaxk+Og%PxwqXap5&6G=&DU&v|o#aGqToOtongAGN#KIB=c(}(2 zZ=`h_F|aHR(WnH4-Uw3fR^Q9plGw@Q<0&x%C$VC@y<8jmx_Y{~qv~<>auOhUDhq>+SC9;ftD)OnNOT87=Cc z&>S`tEJT1A;(p$IyNrs_q7g@*cr+~Sov2L|E0>Zf#?V6Q7&qSJ#z=?*BtarhEr=h@ zX`;CtH9yjflyVW&LbGU1h(~iYebw4nq!EZ^AvQ8giXj3)6E*Feu+YXN^wp}#rYg;h zAk)kjN$==nG+U+?WGyg(33xQ=FR~DNIcWf-AVU}{>w@CL7hq0`gkqS3`a#>HtSS-0 zdk)HjWAP@BJpTHhDfAJha@bob3{pfh#@7Kh7gViGB^D!aTWtfl?&rgQg<Vv+#mgGtMN%N8+2slJCsS^5VT2m=I!HCewr~ zE6Y+ZvW!h;mlNU=Vb91e8If#ejX6=7m2?Jz%4nQvIbV#-GrWq0AnPv4o^gGd4`Z6W zY|-FpETRJk(JnMVk)e!`G%g<*PmJP`_h~9NlPv{hLXM-PJWVoZ6^$HMNz)-~SOR8VqCNIW^? zO!*KqD-l&xrm>n%4ynaJQb}bTO6o2K18qZ;FhbReRblWThB06pwswf^!D>Cpuzdq> z(CRw~O}(O(>p^%DmRczngsO};Az?_vq(FjJTZLI%&Wph+nF%Jh6iOT@VHJT+R zuxz`D;t+A7nE2u*ijm!DqS%s6AVw3#9ni{fbi7R_ihFA#`Uxuqd@~c;wxP|r`*?b} zxw^W0HT3ayZHVUUyvqg92k_~i$fz=7>K#12DDjxMd-C9S4>vS>Q+N1F*+JlrBpVZB_zH7IR{K8z#AZBKN+n~_%$GM%f)V0!6zl)ont5=5Ji>?!@IqF0;^AMfOwo zjYJzW_~hH9mkM?F4RR0m^;WxjdV8bQuV7ELZ^Mufb%2*=pm&g0NJDpDa&3xV0dw_o z3w3u>y9WlKt$}VK9_m0J6vV^T+bhT;DA32l&E2S%%BB9vIihbg+SQO06Q3*;A{3rj zk8;44nf^tM1PUJSKE|85@rs~FF!UmlL9xgbqA{LNmSc#PXwkkeVHc;AF=LkAG+)@w zff9-njQ2uHxw59qO|vByfOXVjf-;803U%%<6pBzC!Ea)POmov}astD2eg`Dtl>)R+ zKZkq_z~{F9OSqx+dn+3ap|C)c$qlxAD7uj!uY)))}vATa6bo?`pIh3;E}#0nomK9CFkSq&ZsO(?FeTWs)bm0l+l+M0T;U z+FVOqk{0cI;^r@Mjb+~yw2!K9bd-o2>*^#rE+HiuNoAH|uj`)@orrXPiz+xiB{>(l z;gbh=mkbmYsN@W-wS7FdQGlVhayo7FV6N=Dq0=gzI&^E#ZB=(hFT~`*M#rg$1|?9=i$v*@@D;Y($!MOEF!JnWbUz7mK~p1BBojoQw?qLn$5rB4o}Wbj zGsjQjS)L!I{s|mG`y;bV`IKiT>VGB}iGJi+7&<5N)F+oBBzMRZQ9k9_v2;H&ffQd> z5cvrBN)y-_DS>2qd7tuJu=ZyO5A08#17F!jJpQkjE68mign{S0rf*ucQkrWkRq0pz znPv>O$MyoDm*$YeGM;$ZC5$kGO1_v!M~+!c>+SFucFd$R>fG@dQ%c|^pNl-raQeSu zGrEbwC2Lb-n~V*+WXmFNlQst}`8oS2x6L1rQG;G3e97AGOXOZ5Eu%yG)zLeg$Gvcl z6IIURzT~_@@)f#P6&c*QK%a0y?-jCfZqYZ_jqX0(X^&9tZ4nZ_%+Lj2Ass&zN0YNk zKIJiaMa5Tvq&Nw^DaQ#(64Q4j_W$LbCBoD=KuRa$RbU(OW78R)h&BXdwqDpc6{xll z+l85C5OrB^FklpAe(k*Yd=aC16V!Vh-W2mhP5)&T*nZVggTHBE;5bc1%}${i)9iu5 zoa}TGs|9&&`YF#$28J3xh;_}OU=uigozS9lN&J3>lSHhP@x3eUEP19+f7w z0%2?`Nv1d}57};}fEb3M@+ZdC+t=B=iljqy1d_??r}1rNu^vnFA7YNdEq42`c1pUt z0wFmz@4!xlQ%l6}0TK6_Jifn?2g4bS2e= p-It_}q-H^qLHX=38<_Lj!8dZWPCRhu7pL^dsYdeodFe;;JOGXZzoh^G literal 0 HcmV?d00001 diff --git a/assets/logo/raw2.png b/assets/logo/raw2.png new file mode 100644 index 0000000000000000000000000000000000000000..0c19e51344eba9e69eff283826690a465983496b GIT binary patch literal 12709 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 O;SZV|-j{ELyZCPem*Q~% literal 0 HcmV?d00001 diff --git a/deps/eigen b/deps/eigen index e63d9f6c..5226566a 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit e63d9f6ccb7f6f29f31241b87c542f3f0ab3112b +Subproject commit 5226566a14ddb4d84214c40809531038f087d187 diff --git a/src/gh/diffCheck/diffCheck.egg-info/PKG-INFO b/src/gh/diffCheck/diffCheck.egg-info/PKG-INFO new file mode 100644 index 00000000..b6273c49 --- /dev/null +++ b/src/gh/diffCheck/diffCheck.egg-info/PKG-INFO @@ -0,0 +1,18 @@ +Metadata-Version: 2.1 +Name: diffCheck +Version: 0.0.3 +Summary: DiffCheck is a package to check the differences between two timber structures +Home-page: https://github.com/diffCheckOrg/diffCheck +Author: Andrea Settimi, Damien Gilliard, Eleni Skevaki, Marirena Kladeftira, Julien Gamerro, Stefana Parascho, and Yves Weinand +Author-email: andrea.settimi@epfl.ch +License: UNKNOWN +Description: # DiffCheck Grasshopper Plugin + + DiffCheck is a plugin for Rhino/Grasshopper that allows the user to compare a 3D model with its scan. + + More information to come +Platform: UNKNOWN +Classifier: License :: OSI Approved :: MIT License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.7 +Description-Content-Type: text/markdown diff --git a/src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt b/src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt new file mode 100644 index 00000000..501a0009 --- /dev/null +++ b/src/gh/diffCheck/diffCheck.egg-info/SOURCES.txt @@ -0,0 +1,13 @@ +README.md +setup.py +diffCheck/__init__.py +diffCheck/df_geometries.py +diffCheck/df_joint_detector.py +diffCheck/df_transformations.py +diffCheck/df_util.py +diffCheck/diffCheck_app.py +diffCheck/test.py +diffCheck.egg-info/PKG-INFO +diffCheck.egg-info/SOURCES.txt +diffCheck.egg-info/dependency_links.txt +diffCheck.egg-info/top_level.txt \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck.egg-info/dependency_links.txt b/src/gh/diffCheck/diffCheck.egg-info/dependency_links.txt new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/src/gh/diffCheck/diffCheck.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/src/gh/diffCheck/diffCheck.egg-info/top_level.txt b/src/gh/diffCheck/diffCheck.egg-info/top_level.txt new file mode 100644 index 00000000..ac76f019 --- /dev/null +++ b/src/gh/diffCheck/diffCheck.egg-info/top_level.txt @@ -0,0 +1 @@ +diffCheck diff --git a/src/gh/diffCheck/diffCheck/__pycache__/__init__.cpython-38.pyc b/src/gh/diffCheck/diffCheck/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b13b9668f30d902921d6542f97d0f3a2062467b5 GIT binary patch literal 132 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 W*!cMb-UvAi`BtAn>7mpe`~LyARrCn} literal 0 HcmV?d00001 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 new file mode 100644 index 0000000000000000000000000000000000000000..3a8482176089be609ee1c2e6df78b0490d5e120f GIT binary patch literal 3472 zcmbtX&2QVt73Yu?MM;#R*p5Gwtg@Tk#{DpYJuLzw&Bl(?6p2wJ-bFzqB`9$uQ=v$C zNN*j3JUOSL2lrC+(1YB=0{I7e*mKc8pvSouD3Ei3JrpR~-y6zb-My8wx*8iJ)2*_TW zWPue_-oNe-q_p(GBKCE}}?d*nWN7>LpNAPr<#A(=#c&DF;PN0~> zc+eTr+O!kK9lz5Re5@8rle#?y%T7P)>wpbFdIu=ihT7N;(0bZ{FjH7p*ihIEG#JRX zS1Y1|6|&;>_On!4-fj}{RGQu>Jiw?A_mHQ|lt=w{nrMLcU+Y`KnN+tQ2N$4y{06(TYlLOsaVW zF*QyMreS2CXoZy_w!_B6$t_x&HHWR?l@p_==GDO5*U~I&=hY(?7_W8lHoH2UnapN$ z!)rn1L`R}pg$<|y>VQUG-PB(Ft#ATX)N*Gyk5OJU^QO|&%3H(vz*y20W#L3izgBBm zVP}hzrQCtdSMn=Z^Pp(w?UHu_J|Qt$F0STRF}GOECFWqW(?>)bwO;xp{)`s4=5XIlJ8UIXnZXgAMjGkF8FUxD_)DUBp6>#(c6KMb^D z7BEK~o6z^lDx5Q$uVH2$u#jJaeLpT1^Tl)9A@|SuJftov?e%=&v=6I)A5;VTt(Grr zYDcVCm`0+L&rhSE7xQPdg)`bhP*bbmU96hV$;&rME8@kDb>ZZTlUq}6?D$yUa}>|* z3p{sWnAJN1LI4xD$%mRA=!-6^LFPV(X@rwjWJi3a|5;pEQbqa3-Y^!Xm zpu>OP;r|A7{d9e(6-(J|l5oVp`{1QsEJOZsP+!oBW%zkznpw+5Gy8b*N!~=>T+dfv z+jXVi*wgZrd?{aEr@jA!WUEa4?FIfD`O@SECmQ7c67p{rA0XD9oNW6HvTjW7kgU>& zueD=CdAN%5Gs_g1%PZ~kelk?A#fJdKq((;HUvZK0^EtIxwjT5BAw>xn=ELMb+MA(2NMb*d)>9r2vRzqy689rN ztm9^&ehmFK%*oJjjIPewcwZ=|Wn3mbxi?O_?_&9f*Ax}wA^p*bLFL_C(2!7h)# zlC=%^JBfLm$*Z3S0rE2oNBkL2Q-8pv@%-6SS$QNxB4mXg8mY9Oq-DHi6^_`?!pL>_ z!8k&+5mGYlQ7|a^HlifufvA#B%O8(<90-f7u!%Br$=WYsI8x3$<6^)!lCjFDQepK; z`XY(KK-P9ny)J7!-X9^Mkkz;;H91RJgEaF-coum*?1sbOFyo_C);EzQlzKafpbJ*k z=o~3qS8oYAG_G~vQ83*`*?L{S_u4hP-Q>WvgK0F}R*I}cjOayymym1Gyw`PSY1gS& z3We+Gbh*_qRqqhjLI>{>w~aRAaT0r@L}X#g)eJpRSXZ*XYtez=W4GEZUn~%>I<8Z; z9w)E5jSC~U)k7Hw@f_sp>Em8GAFDTzTUB)fHae6)rC^NOWX45`SRgOV(feu2L@pFb z7^Kn&g9CRKo*b(wC%R=2 zc4~Fi+N=$F%V-&MY|dzzByR??Nm?5~?VLq6oPvXOGoX@oqB*d#4qnm*8H!F;TWnE3 zy!xGrwY}Puw&%tEh9xA8j33>~P4+(t)B(Hd$AIC{n z78}eriE3qU#z;qLK1F`3V<3J?OU`SU>QQMG^lybaDV@B!Zo+=sQPkCz(k7c}PlRJs zUmTr-OjQioQe|fCw8|)pq%H>H5v0h*+5Zrp3c5MOPYA65;Xg~?8s;nAtF=)VV(UKpYow~ literal 0 HcmV?d00001 diff --git a/src/gh/diffCheck/diffCheck/__pycache__/df_transformations.cpython-39.pyc b/src/gh/diffCheck/diffCheck/__pycache__/df_transformations.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d784fb971a42912f93c3abdc57c2ab3bfbd526a5 GIT binary patch literal 3433 zcma)9&5zs073c6v6!o#++Fd73h}JDEv=#OPZIFdyWWA1q0EuhFM(Zpb2wahpsFg_V zkQ++^d2)c}=w5pALAo`!{sa9-=Gv3by#+q>H#3x0>&9rgc#m)1ym|BH>AfFk-Act) z@cd2PY`USXn(c@Vm`VNQl7=n9C-TR{y9hb~#jn5; zWlB=)2hu<~$mnoxf(jrDR1_K;QVCQBRfMJrX$7^o80ah-&^VayNfCP5S~Y!|}O(53FckqJ2x>#r|ylE~@2<+)9x!IcM@M7egp z_jMn__O*^=)_0g14w>On>W-QA)!rUw`+=mX~YR^com=@uwyR3noomm&%)SB8e z#WQvl&$?9TKa$e4>=kDOAfP{1@>zRV$x0&jO0SxglNGO&tfr+GWE(pZd8)PPdRj`$ zGc~LHpiI}&3ipxXe2A?o)~-!A5_7tlR!ho^H{*)1Tj6$)w!AWQtLds}&o!K69kh|I z;WRh0&2&B8>}`LfWb5e$q#Z~bFUiFpaOy2k4chf{{UxCxqO0(z!c$1qrTBJ}8`JkZ z?1wyT_TC3qdpBoVRugg5{%5>f!fuP($@BC+$hOlh?D-}?--qea?DWG_`rJxun+hzq z)0Isntw5 zKYH%Ri8KD~$ZLyrCYo3z3At$}q=N#9ll1Og~_mA|SNfE*EdoiO8pi;MwV z)y5vP+ZX_(J%98g5!qQfpnazw#7Qd}4DX)6?Y}|F{sg^O!iNrOSD)RB~Bar z$X;{sC3pG}zFjCS-|P4d=d)3e1YxJqXuRgX?&O09(d9eMkDMoykM3~;EOE}FkrTv@ z+wTXR(D!(6qgY2l+;AR74vi8~8BXZ?p6@j#_upQ~V_RN4&KDm$AMZJy-??&uU2-q4 zPZ4C@xvDby8z`9Z84eS(B0B0zKkOu3Ryp>1$Z?p6v@?}<*!nT`-LKp@eng`oFF~v* zoFL7YiO+OC$x2V?7(O0xU}9Q7>M+BnG@{Iqs=}W+a6SEo8AFQNW?Gz3`W}yZ3g7cA+>1uc#`q+nA?{nW4lndJcV&H@r;h2kN_1I)x?TWx z%s4$pcA5D{8gzn?SzmZKUyzJhMTY%_yt&nPWJT?Z%Z}K7ASROU|GGn@! zD$grZG^oKxSUvAtK4fdlqo&LAri+Q}MYF27bT;O9PJyHJ6Bw{c+@iq{s1V{akuWuGF(bSj49Apz s%R~)|%Nx`0@v9qmDv!*sluO`Z-5EsQW#7NcyFKRrSBb-^mbz2>5AQY4H2?qr literal 0 HcmV?d00001 diff --git a/src/gh/diffCheck/diffCheck/__pycache__/df_util.cpython-39.pyc b/src/gh/diffCheck/diffCheck/__pycache__/df_util.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..daa544802df4dc377b7062b607eb61b290c5d153 GIT binary patch literal 3239 zcmcImPjB2r6!+L(uXnpiwrvVYiCP2Y&!SQxkP3S8<~MI%Z)~h- zq5N!5F3-0u>lYG^7YD+J`15Z;xW(DP>XtQIx4RB2dAD0LeO|Y2YQO6Xzuyp6-|jc3 zEpC6uxWnDA-R>#j^jk)*aS!sC7&lU#`;aCosll6&+Tyh7JH=a&&WtR!DvM)$9PMX0 zTd+D4hghHWS%+y)3N@5T#HgVvE^7Mc@aK0xR;*oCSba;r1>tg}rZccEEO> z!jbKQ?V~h0l#c zO47oz^tlzGLW~K^S;A6x3SGGmVquRy!w%1Zk8EnG3b|wio-ZMAhCQ);>%anV2D?lV zlx%MAVSk2q4DTA=HGB;`t8_fWmpXOBmpXpo6yBOGTZLQHOrt-^-) z+@0T=K~=5`1v~`tvhk(acObUn9B7LZ)5haS#c9%$+n0l0!bvqxF9+o%F&c5g#a44< zayIM9-g=O!*<&_=;D{jgs8&c5l&XJC6+Eh6PBmxKA7IM^tMhH+x7U4%|f5V3q0*f5`6(ka{vkI7ficLFUGPDg0j zfl#8wAjMI*9eq}zgZL6PHPc=q!UOMAI(5UBI=-(hF$c|1wU{ z(5J${iP=dQ%};_^0foN9KTrT~v z0usqIYGd)3K0Pi!Jf*&0+5hz!^vOQv!w&voJ=lqZot(i=7-{xBTI+qbalzzM&d!zK zwooz_o5H+DspLWm9&8G!V#=pX=3o*n%7y}IK=B6Lj+f!=D6hJ~SH#>9ZM=q3h z1|pGkO4`ZNOt)@P-tduHP(7)1&0GTAtQv11AFJsGO%$5sYa&mj5~xnM`Xbdsf}E$jW_4-Yo9c1Ig7EK zNnN|W8Yih9H`SG!B3*|Mx3xdwY`LOOOH#@s8D}crPE>D8+Y-rW*%GBl%(j%a^GJJY zJ3}I--A`~Ev`d+o$pm%Xc;_8%vL<9>X*w`ZqNM1DONca#u7+9GF)x@1YqB!`{q>X& a2jT-dwtNzVZkNxn9cOByT_1m*zCQuMKr$r& literal 0 HcmV?d00001 diff --git a/src/gh/diffCheck/diffCheck/__pycache__/geometries.cpython-38.pyc b/src/gh/diffCheck/diffCheck/__pycache__/geometries.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1c31d0609c6dafcc633119e9f7ec5a7a02faa410 GIT binary patch literal 3939 zcmb_fTa(;I74DWa8jWUVcWq3-5QuOBWRk^%vWrS>ZHyC#P({H&;S2U)myoA>b~T<` zT3VA;nU~mAP`vRRsB(Do58%(}m8bj#p7_4jXm;(Lb$EzWeRTSI&gpZ$)2*A`ZYc2l z`)_AP|7r>GA6AY(9x7K+vV9OGl$?mE97svtnK%Q-e%*nq1g@=ep>%zkoE+lVwXKc`}?NS=Jx2>G9bEDE(lIzT_RLW0Ed05I~ zD4}Bgkatk7p=57@JQ8EE2$XyzV)Alv&hn^_oke7MY%?@<`g<5|pJ%S2YfOX02YDt- zFVmCJGhyh_|GquixvSFA=-R#>KDe8i;oZIcV-0(HKGnHNb#`%aSa#!hG0*Ziouzpk zZ(@GNHHGZpEzVWjbMd)BCrsi5YtpM=sPtHTh8Uqi__{RaGx1L!W_bM~td`t~ZogM} z+tD3M2k)6C=9++nMpUE?t_e5Y3IzWS->ZW*jH8**s73bUw=60 zW5!$jRFU^AZRGyb=I3G@prvJ@fEeoBoKYJU(dI9>%f%b-S9VMfvOL;P9_lE`qlr#X zyR@>T7n-kQaOqC;%)CM_yp>E2^v{i%8}kh`3|euT#n!UYJ2*&H*&w}Ky0Eo$VePsY zwNVpcdbR;V>}((|I!;IWvN%g6zXUiq(G=w!EF_*`r!DmvQ{5kODu zL_ODk}K)?$7)=rxNvdE(TzGl{fV|7HY{(-S@ zuh*)S_9k>R&)l+g14Amve+zZShHdAGYqRi?l^J_K!>B9;w-iK%0SM= z0P@y$W!?)2rxEMGV2`a|Qo$PGOQpUH;YVmQ5!e3SX#yDkzeZWX%?e0Wzt>%dH}g6d zBHqj!B;O|?5RMRLe!%LfxcVV_-$k)oUgIig6IF(Nrz7eHdS67;xS@TVw76*EUKrqO zPuv#}<*VQyQt@Ky4cfY++NklY^#)zF0fcRq!TVXJr}rm^#pRcwY!>0}YR54w@580b zt6{_PHY`toh@P_`Vm2X&5c>Se#TJi+7&l$$;Pi{F`UtF*={aT_bE=bI%{|KQ`5lbN zczYB$pNd!NxnEV_hV_C~@G?4HJf5tM>(t}%bdTySgZE6m7L=<37(WFbw{B=h&27iq??3DGp-vgo%U{GuD%^OU;07}mAL9B(moBr}bN=Tt^bG-Hr!ooNJNsuCGZudp z4{+~)B>(PwjH`fE8Yl1t4DC6kbMc+ZmUmFE46?R_yUcpS`E+qbaZv)@$CibncyqPA zMo;GtwKe(T?qohpCfOA*^+ZUa&+0Av$x4EiWyQ3QEit4VyCL{{SSO?3+gO_`jxq#+ zU1g2e$*oRf^J7+Rj=oH8-9h{|I(~<;N*KI|1zzB8xQ2bb02k`|$5Lm8npVllo&xk* jm7%N>oUu+!8SGa77gspn9{M=!CDYQ@7RqZV=NMR6tV+I7<=X&dH8+o)Y^jo3(w#m3llTNecawZPh`qdFkCn$a$0 zNmPbhH%qve*g$*jIW6E^3iw~*wWk2N_106rZzyVi$&M+^@Ns^=H}8AjJjI<(VBz`Z z-&aPjL;4Rt&OR+nXXGur8Pb}#^wjYauYg!u8 zLyKox8m6TweYE(d#WO7}8K5OFElp|fTfMcfv76NsWlP3+Jetfl)v?jK^fd7e3%uF(xv9;#=e zbTc&>J+m}D`oEvw-o7uB(P-~T4IkXk^zi=S(V2!rl}=Tz6P0bvPs&ad&C@K8l39{R zQ5W+wu4#!je#N!wc(%?Bx?~b37?XYgfl809FM$yngttRuzO?@3!3?)w1l5w;;k^$E zcQgFN)PoOn6LYoCibhn`8l=*XB03|AzJsrf$7hLReW_U0*YEipIE$w$ipn60rl~xh zP;N)jXUFkm(bJ3~nGVt17){bRFV~|ep3Txc&XaVOVW&2h*Bw@;Y8Z*SXa^Oo%{VNu zUB?&Z*DyUpG@g4nd>19VkLo!%^~O!*ziI)sK&x~IEfqj+Kn7NySc5g`%NE{k)scZ* zdtxELx{%wlW8`(|;$XX_dpjPg;@%5!Ji?I8Fqwr*co5TU4FUWZD4tBzkVg@wBZK;6 zSOePS36?%XfsOsrAE(I-z>$~mu!Q&@VK&iFLp(RYek`Q@z|wE!j&vT2FDkJA><}X( zV#b}nFDbjGZsgw6=2zC(M@!3u0x;CRJEJx-q|IORl#6#htn8Q`XL)!OKU86yhZ7a! z>&DWOUZB5=!KE`%GyMvs;Ny65tbVI?s`dBKFla?d78%P*_xL!GWrOw2(t)j|18Y}d z)S%`KOwSlVjGZoU(YD*d6U9|3`7IH|Sl;9O@1r`6p!&QJJ#@0uFFY=`9Tx4)kP$#n zY==F^n5AFEWMkG!9SQ0l_gI8bXQ5XWK$o0It}-goBsx(CQtTtFjUsn$_k=mHRa=#Q zeTJLd&+v)u30D-=o^|i@_v94rxes#dKNI>#_+Gh_oyhmNhq1{nn#QI?_BJ%t*6XY` zSY1I?I$5qYX{7Y>lX)^bEZvV1v=Kp-H9w@ZvWEDKGF29ev8#AUbu!1!Y89p z@j@3U@B`nmMbNN?X2%fa+{1l$Q8EU~%khJ3fD6D86+3_nR`P>v!%Lmg{k4jx#oZTj z!U2X{<^;B`;)D_4SKV+`BsEOKB}bCS4S4QAILiRVMvZAk`=6}YYp#_$C+`c3zuc9` zAHEQuSTp-N=h^e!iWl<6Qx7cA#4O*i0AgXu0>(P@0Jk%M0+`_Or+-+NIn4oXl#Z_u^A>0i*F`f_Q zWo+>xXH@m<;yvRfW+8i8A&&^-kSm2FolYquOvChG40>J;>>Dih?9v%dvVnWRNIpfU zxjb8(90^V^+Wlk;T+TpR*)uUE?%!j$5ra_dZjySNMEVff^rqC@u$Y+ z(G7V>^+TCXH;2ZXiih@8JQ80C{?ppG4A2*cQ+n}yu4WRSEezGySzU;DKbA7$HY0Ri zR;KR7pN1w!F@Ia74|U2&ihr|4LLy^(f(&eI{RZhLUAo}lbN=Tt^bNzvOeJ-HdiAd` zW^Dc4dVv2ekHkOh&ydPg#3fAdfWPdm>y<4xFtswsuvf4{t{$e-`K>W}{)=K2?=BBk zt7-aB8DqD0Ch0JqWVayHQ;?z1TlHbxgj}s{b}<{QomnD5e|=upR_)R6bysr7DPu6C zD;9a1(lU?G%u%X4g`k0%0EEG<6{T7{oyaOhAqU5Et_Ri4=wu#ukPsh7_h?22JK8sdWZo zu-X!!+Ga*ZpdO%FCci3fkJOx;e1-D-qMQ^>##^ifMVWaeD;bJFn!v;_eK)I^l+3g= z=Zw_k?3m)BWWWgww2!N9=az*?K>)7N(}}%uS4}SoHKPY%M@~ zdd&9j;n6HIO!SlEQ{mC-)vAhI(;U+rYOr96|0QXAhH3Z>7Df)kgMk64z`*cdX}?Iu zrg~;3b~Yv;M++0DS6l`D2fMGF7XrR7kY(K=P{;5VYczSDAx1;4OxwECcVXN?WWx-$ zY9*AmViiA}V_tkX-YJvQjp`CKp>Rq~AniZAYcuJRDqgHWAkT?SrP1S}Cll zApazeDl=6wb^z~+=Vyi1AFbA%SF00+j5oShtAc7K6kk95WMQ^kZ_rMXS@5axJw2ii zgv}^ArPsYI}W&u_9|j0!^D}GP*a& z0<-UWygi2YOu^&2i@3mp%%i}kSG_59xu!eKOKT88N;@|sI6Ev62n4wG2^HC^?(N~qq3h>Vdl6mWm zp3LeJY&5qjbJNQtL+5lGE;7QB>70v~G<98HT&wo_7{K~K?HBAEPqnX{x!N$SaPull zmnxm8`al}Yg0~R5z;>kN_K$`7+dI90IqvKx{t&-vPqse!0siPZV~@f=CS78QO?m*e z1xd=pSVQ-G&m*s_y!>AIlFnViVYu`9Cqp=t<3-g4*X||#8v@@z{XhSaZ2Y% zJRJ1WDW@Wd(Y3l5HJn-kVzr}(KWCgnTs75!81?ppMVk&`kDWsE^^) zkzYYPO{Kv+#@dwQ;v=oNc~P)*>~3V?_?1L-0zoqZ|JN!mM5QX>wDKTeJQHc(8RsDF zXUj|MuVLJVFLyxFeJGr7m%S1Gx{bQEToo_=9@%zY6uJ@AJfY{D=M%iJc~5e)3> z6PbnlJx;oLuAi(W6nUn=uHP{%q#%+SS-MM-gc|X7BM`t7=MUMtGK?A;qhLKnt9=|F zDn0o|PoQbEK%+34=|tHk^G=AT+X6ObJK;llTd<=!ncF6$3|z%UY6XN*rC+Y;LC>fq zjULw*!|EjH1PzSo_T~9@Xw7d~mkEw3B=R9KJ@bkbN?-H$o8iHjIGHfvAt{l=jQB(1 zC4|1fp!#goFFN86B@p678ZvfAF8F%O-ZQqbEtk?9z(nX&9#4qD2l2h@F54vp?L&(W| z5RG@q$k9-Dk8k?6G<_=%8|;tUo^C&~U{HmuPCHdtdZa-NvT)9Bg%Ghn_|mAi_V5Nf zR4>rHO01zmKS6c*+<$%GWIzgTuK$zFevex<$nbGEcefei6MdHAM#-ohiR5=TQlsz% z*)GqVE*isFVqtBsJ_l!N1YM#JGD^Zhf;d?D$h7_NKs<1+cX3(KUkLI2%pR8T^n)J} zN>-Qy?NQ7m`xTFbG%BLrOJ3N?q2^PQqf=$lXxr3Wm{x>sxS)Ok27FfgYGY?`V=gKo zHtDqBknOo{+l-jk;y}W`LJCWe>5KZUX2!O(x-W}(V*R3h-5J;hvvh7ARP=cUsiXHJ z)BMhx;8aPMiWQ6qF7=X8_v?K1ccQMg6=aB_FE;j?te9*UsPh9(o_YI3i@c-HFdmOO zNzksuf;R2TEeb0IkRm*p$RWy&VO5~+JFLNNX#`dqCRQ07R`mo#uV4v^^G|TOJZ0#x zdsM5y-3#}5#u-E}! zE5(w}l|#ZH6kPO~wG2(g51iwEQ_(H()?;Ob!#c{!1D1ul-oVDPB>L8$?l(t%Z7?X_ zC#os8gNuQ4Be4nXot2Gzg_yW>KnPxZt+^>&5a%eW`9PVy^fH?fZL5>jWkP~sf5aeo zv;e@ug4co+F3lu^%jI%QcchXePnl4Vx~BaW&t1vbt&--}3IVoYx;jdB=o7&{z;~47 zEgMIZ9Q|WlE~EgmfQJ^d3+xu(UTe8;rHcy6 zso!`e(+^wb5;+Yu_0Q85VljX^H>9xUuA(CEbI=#6xo~i@Y3{KyV^l`Qx%aLWcEY6y zKEp*6N`^+5X{d3@>4%iiEKllB8p;>wrA+CL2;DbG^$?e2EvN3(NA4V|94)7Cc}L6p z#2fO{8WuD+x^nOogD>>a;*nr4y^D0eM2#0D)z)ifuzMxz>-el;fJ34jb#fU>!{Hu^8VJQ!%o{HoE<5k&l58^=>?mLG&7ftDZd~aVw z{?A?zg3D0rZ~eRd-F;y=OdYf=|e;@C=g97vlTu!kc($N`|mB zsn?SNCi6V%vqd#6y1;_B?Ux2!7)G$*>^qn(A|zEvQGO-089Csq-vk4l@YKnZvaC`f zkkPZWGJAAB*hAlRr3;xJIDI?vgcYr35h=__O3P?2zOoIC-c{M>3GVdi%_DsH@%)3= zWqeXSS`({6ud2+~!I|d)pANm_7ta^#m%JY*!#<6ZeB(7Dh0VG1B#=0$k+EOIO*ej~ zcNURq>>OnK+=63>W86}b4cg{GX{Q(9w2WOfGLbdHGEt$7(|K?3vy~suy9H>SC2Tks z`pH!g49*$DJ)lLAq*P`N+Y6#{KO$d|7&Z+(k^IX4U~NJ*v>IzxxnaS;28qDHi2s`Z zS=w3Hg7l0{Kqf{YJIB`?Z~$-F_ABSvn(vEWHA$`wr}S|>i};6miMhfMe^Q5V>>#oO z+#l=|g=fhCwQCrIIM zn1PD)|)6~c9vU7AOm#_si;?FT*tScsW2 z4Pk&}k;SVE^DW%Vr0x4MLE+CiPF|i^MM43tu0AKMwI7#G;}D&YVU#IUS@~Ah4DOD9 z{AfuYqgosn-VTTOK(3dC*{z6_q{%-Y;Z4a7N1-u}4!!G(#8i{#m)JW8!|IFrhF?+2LW?N?vI6c*cI$@o+;55;S{p0nyy+grh1934F@#k714Ah1)Cvwf-1JMa*b z&iP@X$peRySxN#K!ZpC!+U&Sa$?5S9rW~N*$3#Sf(VjXJONUpUa-?cC1t&4RAPRa~ z>lAE;*`&9x2B)wm0z+-#0XGoAeEMmlsx6#R7UYZM6ebw%W;Rn|y8ZQZ=Wm!6@OsN5 zOZ-XRsW#T5_Z}snmW%Jz=ep6Kev)Yjk|#Fh*Of%W2@y%za=%`a$_Fx|CM(0gOPj9{ z>g6KEHXX^T^T+Xi-m;=`m>$Zk!@1-5-X|_K@l#oO4;FGP!YGnT-xfSzL&GIj+RVsh zn3vE&LL$Ky4UIZ?c>R529|v@CPsul*byk$0ct3zCO?!ijz;R=I-C?A#c+oM4Cy!7S z#f*9@_bktXp7$a2Z&jZmL^r`xYrYxXY!|Z(8^UkDcMCEI814$oE^ii_CM{4MrAOv2FYmhJ{#bizt78Q+j&h^~%P2WWr#E3uW+cV%8G zegog&>(&Ee?`R5=#T(RqR(C8Md=CQJJl8ef7;-Ix?A`{Fc#!2n+aRqG{aYe}d1`aN zVh*WdtaGR#Qbv3{x*rePqEt;PBAz+OtW1(BZz$bqcqD}C?ZAmL%WxKrNReE~0JH8D z8wO8NtMb-RJO*FDWp~kwl1S)FZ_2{&>16YyQ7W4%HhPyf<>tOn)aOEG2{_Rtt^bD88z;k0e*cd?I6bas)JkPWxX zb!Lpr*ve$u?Zou_UG^4mn1tgRiRXD0eR#?&=dzrft`Y6dL_7^lvQ>#?gf~aMS+!Th zZ7E3e7!z^0b`2cb@iqO?n+!q%1P)$2?;2!a99oUp??Y}O)9cXz5*gQUTMwxMR|^p7 z;^G2_Pkm=TLgF&rgP3{L4fp&_Y}UmMxCFDe{7Z3aHmf~yNlP!QS5Vjuj=BJ38s4HN z-z9(cS~N{?_gPe?2-a)|C{XG`NjN5dFuMMU94el)AT^Nv#g!SkM9x;Wag8#6Ra1vI z(1Sg={KB?CF&X z%jIVGlHMQA5}}?`eHj`KVK-G^q9XVHXfmaIcE#MBq{}6~MD9yGK6Pt`Tmg{YTUaDh z^)39t!&__u=)MH8-~8mF z+4;8Np%-)v38;m|5SqgSZ~fAve_6AmG%YKeLS(%>YL(2^^WMxp{~Ps#%X@p6=P2?m6PMTde0=^#&jqR z=P7U0HcuEP@~d5nE-A2;FPu3hKH6TMh7!x~613Gj?9?eRNr6HnV($47(ZUIuv+EWF zho{W^V)9N_R;{=V|8AsmWcmjQ-`%MnFy9c23Ys;92eI=Y1!Cx`g z!8t_3!4!^z5E=~Z5e*EC%-jL_hTw4L}>Vn zmcvnXei3iRljBmEeZ%%F`{q-XXhOFT|8XLw6|4w*L*o5B#$m0_!*`a!Ga7d(W>ROg z#JH1Bn*MJ&D#i39^2kbt%qHEABWNxSf{#-3JobvScuLLIN{u9(kBg&-zBn`;^($p^ zmtsgbv!@bFxSKz>eIJlf8gxo4K$C>YR3=*>F~obVJeXf#COQof%1v-FkZ<4_^BM01 zGC0|`R-C4^#%3c>MlK1Di6Z+YRin}%9F^!1Y-;(5hwdKejgx@-JtDOeWFIRHZjwvh zvp^UDt*iAhap4l9sVbQKX@F)DxB+275cm+z3`@kNgavRgBu0=U{R|8$5jkv>m>$u{ z9Sp;KJx*_=GCIzCL2Xbz0DSk|BPl@w8DlO+_z8?!8W!McZ7=Luwuey_Z_q$};bW&m z45~siO$fBY`*B!=b1H_M>1orezPDU)oDPy{Gd;(ZPA;cYhF`R&K3}aSX=83OFc5g7 z$#mq+K;GxwDoH#S{hnU`55ahDM0cEa`&j2Q6}8C#iw#K@vKI2Z z*SdTt7?1t8|vZ z8}+6$?fDPc_#>&4nYwAJq~#gkje%1s=!*dY?evzLami+`WQB1`f@50iB8|0-a|Z}J zU9-8(@rM2xMq(g}h4czTaQXl(u-cFM`H2tAG|x<4g6O_Liz=4_OV6Lx#ow>=lS$v= zAjlUHsq_%hLvL9FY1&DffDB9XHcA%#`IzjuUqhG(C0i5=5hB>ei^k$Yyck=y-SNd{ zNUbkt`K>0JV`O&ZyWW{Osp}LRopF8^%j-JJ_o@b%QurP9Y^qs%dS}FeyDK12`LD!J z8+0jsn(IgAos{u3@kQ*#?Ub)IKGt?JbM;0%Vk=4#M*{?g62^3f$J*^N>Mcs zDdDXZk#R62VEzG-;Rmsq$x@g#_40n)-|#fDa6AL7Xz4seaUIN1jElZ<6iO&H%%Gz?4d}*MOgt*oxs+B@oc{a~CkN zgPqBaE8=&RbxE#1Ck1)#u+*H8Qkv<#(42IPbXf&|j1yL>j&k*f;F+PXH+t(MznQXc zxu1}2Hdhi$;joQ%w%p$D%>A?hhTK?=T-X6!RYXOH zg(5UB8yy|2)1Ct&H#Ql+2yisUH`IOhMI}jGdbjJg-ky5SPxIb=k=|yxjbOR>NdQj( zt4e6i?+bw%exbU*Qv8gHR^x&-zP8JxEleAiYH7{1W^JnFN4x43IfisBo8wb>4fcZ- zE%;4DfQ|S^M;AAI#Q_3~W7RZShoF@2_s_(A8$CVXe78{L#ybOu*(iBzODkh20@M+rE2BEwLdhTh6f&1tLzBFFLN~5LeYPhbzX+;IANed z)gz6-9)K0YANw>Bf0>jE3#BLPh&4q7EaAL4VMq*WN~$8bcL(Tj>I{#XR%Eh$EofkH z`>fKz7%#sy&q2w<#Ip zix7;~I44%+Qe2bo)=9fms;7e`0Zkrw&1MuBJVTj|TSU>-AF|AL7n}1lq4f9B;CIPr zp|~rq8EAg(9W-{QoQ-Z56_l&!rC@$LxilxahEsA)-k@8!AY&KVf)l$&Q;ngIQ;T8p zDhSb&s*c;Al+{@tzlpiEUqwrDwthZ8Z}FF(a1$I`6|M2_YueGuTguR}I1ksN3fst6 z&dov*eh%XPpu;$Ca-mKs728E21?#R6hkT(RrOa*MK*t-mmrq?2i6ZGZo%~`RP|4Ly z`ALwhmC|3*ebtjKDJ|!8Y3n>%GNM{Re(C(<44_L_I#;HEs#RAdvDIo3yLlD@I7xGx zQ_&ATDp!zEn0gvnXdn_=H0Np_V~*TaLZRH>Dm>`^@+BZ$3W@|QV z$=8#acX+S0VKnKE;BwpNJMmRKi^lkCa5(ig3m3XsF@Bn_S<$h17RaC)dOt({$sDxD zmXnRJw*F4Q}FVY`FwnQ8s`Qe@0^Y@ zpE$E8%vRiR&>w#^I5+7&1x)HAn8l#=J_D8p!c!-8wWCTlkwDVNGD(AQ6nl%`1d-qs ztZIo(!tb9T3r0>)*>aZwX1>rMt&(hkMwaWqtUKixPI{aO*_Guxp0mw*x!k@08^HP6H&!28AQK~n+bK5mWG`NM+p!7vX_EUKc(~_!24~90YyI&j6WWDLGtq25RBhH`9i-pP(LNQx7ufKhlbZ_U37~XJ2 zY|}J8Nk7#}8~5!ZT+m%F)wvZn17nd=KkPDU5aI3gWODL&S`W$4`n8+56+ ziHy9WKF`I>6Rw2MkCU(oaPhgi&gFxYNgdItH#Af=u2tm$ET_rEd{AQ9k{OP7{Cfq2 zDhquSy62Y2^elU&Ldbo00M!65$ldc6o< z<(E7E+r|{+Z*5H%jW7*N=fcy(*CC^?@|tD;HWXyy1bVd^fruJ}URG40TcKyN?Oak} z`;#2xOei$2*tkMiKz@t8tMtPyCw6P+kmqXTNc>fbyp{!4Py}Vr&zKm2Kt_Hlhdc-C z5cMwFXes@K?WL*{rIicx2rSRl&rMv%q*>a7cW7>gP>v)1YD~hW@0lViz+q9-j!gz{ zq&J~XW~d~f&zON(onEY$ZdF*E1zF!-cAULlew%~gYim|&YmuVybqO54J_GXK=fK3u z%*xEcY;55KVzRI`wPTSJQxO&wRuN8AmW!SfLh6{Rs_t))!}bsw4J{QLt6fEz3B;1% zazHP;EWj%&cp)wV32qMB9N!+hH*SPM5nyIK=OpmlA-u&roxmqjowi?P_9#W!gKnp@ z4NF}HOd9a2S9_U)nF)nxkW^E|fL&8D2z+Q&B-eW%Brp;>?4JPv*Cs$U92cY&B)aSc zA62MCpfVlauajspG>h_(i(KiYR427&rN8HYMW)JnD@Ptc6w0{=&p1=_3>sTtFEoY7 zW^xZ&^NVs*^a>1B#p>-C2-4aLz_{aGl8KGVR!-@bFBaRiW;3YtoXD};+*gutC%?hh zdC87@*Z2jlER6g`={(fXD!i2oMJIlWck%Z6$>Xw~Q#*V%Xh)X=F`UO~EWb|YP*Jsd zd98)9C>sjOErr`ukK|Rhh!qoF_SxN-KP~! zcX;gToX{Edvz~G(JhB|OyU}__O>e~s{Vkbz$H@XR5yNwp60^lLpt~u{n|5PCG8)3% zhI=>MFNmM|i*k>cZ2oQ?Rr7RAVEhWC2Kx@aH~3)rC-kN0vH_**hNy^pz%Qf!)d-F)>-hDM`7B8Nk0A{dLN$^BkLw3KKF+(u^Z4waSvxBaF4_29T4h=~dbwQ$DcL4v+G60s#MqR~7rF7W zoo$G}m?Nfm_8X*Er4U|)=2iZ?8vmvk$j)BR+Qh}gni=E=5VZxs z`0mxVTV69Z(*Frm7JH|lEb2YO7oRJH3BBp%gUAa9`UXV+Mvel#TOcAr23+CSHdlJQ z<_p!9t&U%7?NKk99I?-0P)|t8c8DO5{pKbwUf4xV==)LH%nZ4n+U&#oW*xG zLOm4?DLykMtB3PZ&s{clT-)>5r@C7H&YVW^`o7|9Uqr=S?@n*Vl~~R`qJgnkl^v>i zPlNuSE(ghaoeV1I+JWQA)lh;XxdVVm4pAlPRomXm`2YbG01&q0tzJR^&dmpSa4iuu z=&clqot4=-3Kg}nkeF{iwe>P-Z|&N6KR4SHIwXG585iDKmK)cVZ~SqwO7H>Ipi8Q6 z&gh**7IvZc%7uS7Tnv^^t7}*pyeU@4)*&~W9&s!aJ$|FA_@?{Bj)_=8+Gwr)W`?1< zHXQ{cX@=n`gFIYn3^>!^*tpa^dRdrqaK}VRmW{Z>fdvDns(K}Iy;<4Zhz`}=q&he%xR4;Cez^>JQ@Oej&*r6nU( zV~HK)j%p#D-^-`J?R52Ps;u9HQy@pk9eq2kfj$fOnpbsxFm>f>(y60`N?X5GTdfE` zIws&!+kwfAe`D;_7puSPEkL#Ry{WyP${`R&W#TZt(>W1k5=$UvdC37WSxw5=JXnr4 zN$4t%1^|FBt)wQ{!SZ3b4nHX!o&3NyKBT880}g@tuhQV3&(XYE;lHj%zdwHdYvI42 zs`(x9PX}oJ4FCgc^ppM*;;+YPe&_sCBjz{G>x%oO$}8t@(eHQGKW#AmVs*X-!#}b9 zzTNaY?4OFNUof24BS?RO{inqGo$yb&+%LlR>ye}12!F}!e&_sCKJbgPNBBGEe?Fgo z$_{>k$X?rEzZCjUuJF4a{}h;i4d4BJ_}~2E|A*&NAf@|@z2yZ-|Xh^5{D literal 0 HcmV?d00001 diff --git a/src/gh/diffCheck/dist/diffCheck-0.0.3.tar.gz b/src/gh/diffCheck/dist/diffCheck-0.0.3.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..882c8b6635556892e557a8ce08d5fc6f46d3e476 GIT binary patch literal 8460 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 literal 0 HcmV?d00001 From dbe7d491ca55e4284876066f4e7a99cc0a60a483 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 12 Apr 2024 14:06:34 +0200 Subject: [PATCH 034/141] CAP: finsihed ghuser for exporter --- examples/exporter.ghx | 965 ++++++++++++++++++ .../diffCheck/diffCheck/df_joint_detector.py | 8 +- src/gh/diffCheck/diffCheck_app.py | 6 +- src/gh/tester.ghx | 70 +- 4 files changed, 1007 insertions(+), 42 deletions(-) create mode 100644 examples/exporter.ghx diff --git a/examples/exporter.ghx b/examples/exporter.ghx new file mode 100644 index 00000000..b56dfb0d --- /dev/null +++ b/examples/exporter.ghx @@ -0,0 +1,965 @@ + + + + + + + + 0 + 2 + 2 + + + + + + + 1 + 0 + 8 + + + + + + 6d414e49-3182-4495-b3f1-09564af81365 + Shaded + 1 + + 100;102;0;255 + + + 100;0;150;0 + + + + + + 638485274587794356 + + false + exporter.ghx + + + + + 0 + + + + + + 176 + 84 + + 1.2750005 + + + + + 0 + + + + + + + 0 + + + + + 2 + + + + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.6.24101.5001 + + + + + RhinoCodePluginGH, Version=8.6.24101.5001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.6.24101.5001 + + 066d0a87-236f-4eae-a0f4-9e42f5327962 + RhinoCodePluginGH + + + + + + + + 9 + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + + true + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 710c15eb-570f-4237-9cb8-afdde0961b0a + true + false + true + DFXMLExporter + XMLout + 1 + + false + false + false + + + + + + 183 + 45 + 171 + 84 + + + 290 + 87 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + d48261d1-1866-4c21-a3eb-a7e98ef7a2f8 + i_dump + i_dump + true + 0 + true + 8c08df72-4af6-478d-b73d-4cb5062e929c + 1 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 185 + 47 + 90 + 20 + + + 231.5 + 57 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA7xJREFUSEvVVUssnGEUHcRExPvNeBvvV7xf8Yh3YiFBlO4kbCS2No3Gqlg0BBuxYEeINGxs2AgLiVZiJSzstJW0upjpQ01O77nz/0Jpq6umJ7mZ3/zmnHvPvff7LP8Kdg8Pj8/yib+IJxKPg4+Pz+v5+Xns7e1hZ2cH29vb2NzcxNraGhYXFzExMYH+/n60tbWhqqoKqampkITeyk+tbobfwMvLq11++H1hYQFlZWUapaWlKC4uRmFhIfLz85GTk4OMjAwlTkpKQlZWFvz8/Byenp7PDJpfwhoYGPhhaWkJnZ2dmh2jsrIS7e3tMHFycqKkaWlpSElJ0UhOToYIOIXD5qZ6AN7e3i/6+vquR0dHUV1djdraWg0+z83NweVyGRJAc3Mz0tPTlTwxMVErkeS+iVWvDLp7sEdFRX2dnp5GQ0ODEtfX12vw+ezsDCsrKwY9MDk5qTbZ7XYViIuLQ2xsLHvBKorclLcg3u90dHSgt7dXbbktMDAwgOPj4zs2HR0d3REgeXR0NIKDg10i8sagvUFbWFjYl+7ubm0qPb9t0fLyMqamprTZp6enhgRQV1d3YxEFxAHEx8dDptAhnE/d1NJYyf5deXk5GJwWU4SVUOji4gItLS36bnZ21qAHxsbGVCAhIQE2mw2RkZEqQkGp4qNw+1mk889DQ0O/kJwjyFEkEbOl0NDQkO6COaZdXV0GPXBwcKDNpf8xMTGIiIhASEiIisozF/WlRZQ+ZWZm6mwzKFJQUICioiKNjY0NDA8P63fmDpyfnxsS0EpN/8PDw9kDFcrLy+N2f6LASxkvZ25uLkwhPpOMFTgcDoPqYYyMjGj2tEecQFBQkPJIVe4K6BP9YqmcCgaXKDs7WzNfXV3VZ37Hd1yunp4egx7Y399X35k97WEltFf66u6BgadWq9XBH3P9+cklOjw8xODgoD6b7+gvR/Py8lIFrq+vtVoze1YtFnEXbqZIwdmld1x5koyPjysBBfg3g1WaS7W7u6vviZmZGSWncElJiUvo7u0BUcqzhARcIhNOp1OPCY4iidmj9fV1XF1dGf/hxtbWFpqamhAQEEDv728yIVW8Eh+/MVtOxu3gnLOZ9JgNpeemLUKqIyyTcyU0vzyLCBuroN/Mls0zg6S00CRmQ2X64O/vr+95N0gff3+aGngms+zk5MjxcRMmKefczFruAPj6+up5JVWT/I/3AWEVq95zLCsqKlBTU6ME9Le1tVUz5aHHg5FbzfOrsbHx8TeaAd6vP9+5f4rH38n/ESyWH1B2wifz0XRNAAAAAElFTkSuQmCC + + 9808dcd4-0a56-4762-9ba9-bb0923820f02 + i_assembly_name + i_assembly_name + true + 0 + true + 642efa41-dbbd-47ee-a53e-e1f51ffa1f12 + 1 + The name of the assembly to export. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 185 + 67 + 90 + 20 + + + 231.5 + 77 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA7xJREFUSEvVVUssnGEUHcRExPvNeBvvV7xf8Yh3YiFBlO4kbCS2No3Gqlg0BBuxYEeINGxs2AgLiVZiJSzstJW0upjpQ01O77nz/0Jpq6umJ7mZ3/zmnHvPvff7LP8Kdg8Pj8/yib+IJxKPg4+Pz+v5+Xns7e1hZ2cH29vb2NzcxNraGhYXFzExMYH+/n60tbWhqqoKqampkITeyk+tbobfwMvLq11++H1hYQFlZWUapaWlKC4uRmFhIfLz85GTk4OMjAwlTkpKQlZWFvz8/Byenp7PDJpfwhoYGPhhaWkJnZ2dmh2jsrIS7e3tMHFycqKkaWlpSElJ0UhOToYIOIXD5qZ6AN7e3i/6+vquR0dHUV1djdraWg0+z83NweVyGRJAc3Mz0tPTlTwxMVErkeS+iVWvDLp7sEdFRX2dnp5GQ0ODEtfX12vw+ezsDCsrKwY9MDk5qTbZ7XYViIuLQ2xsLHvBKorclLcg3u90dHSgt7dXbbktMDAwgOPj4zs2HR0d3REgeXR0NIKDg10i8sagvUFbWFjYl+7ubm0qPb9t0fLyMqamprTZp6enhgRQV1d3YxEFxAHEx8dDptAhnE/d1NJYyf5deXk5GJwWU4SVUOji4gItLS36bnZ21qAHxsbGVCAhIQE2mw2RkZEqQkGp4qNw+1mk889DQ0O/kJwjyFEkEbOl0NDQkO6COaZdXV0GPXBwcKDNpf8xMTGIiIhASEiIisozF/WlRZQ+ZWZm6mwzKFJQUICioiKNjY0NDA8P63fmDpyfnxsS0EpN/8PDw9kDFcrLy+N2f6LASxkvZ25uLkwhPpOMFTgcDoPqYYyMjGj2tEecQFBQkPJIVe4K6BP9YqmcCgaXKDs7WzNfXV3VZ37Hd1yunp4egx7Y399X35k97WEltFf66u6BgadWq9XBH3P9+cklOjw8xODgoD6b7+gvR/Py8lIFrq+vtVoze1YtFnEXbqZIwdmld1x5koyPjysBBfg3g1WaS7W7u6vviZmZGSWncElJiUvo7u0BUcqzhARcIhNOp1OPCY4iidmj9fV1XF1dGf/hxtbWFpqamhAQEEDv728yIVW8Eh+/MVtOxu3gnLOZ9JgNpeemLUKqIyyTcyU0vzyLCBuroN/Mls0zg6S00CRmQ2X64O/vr+95N0gff3+aGngms+zk5MjxcRMmKefczFruAPj6+up5JVWT/I/3AWEVq95zLCsqKlBTU6ME9Le1tVUz5aHHg5FbzfOrsbHx8TeaAd6vP9+5f4rH38n/ESyWH1B2wifz0XRNAAAAAElFTkSuQmCC + + d8eb4d09-c5ce-4358-a4dc-869a7ee7fed5 + i_export_dir + i_export_dir + true + 0 + true + db74a3b5-1227-46f8-823f-2e8caadc27f9 + 1 + The directors where to export the xml file. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 185 + 87 + 90 + 20 + + + 231.5 + 97 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== + + ff511bf7-48db-498c-85b4-744eab811099 + i_breps + i_breps + true + 1 + true + 09820e90-22d3-463f-aeb1-e7a483ab60c9 + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 185 + 107 + 90 + 20 + + + 231.5 + 117 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 96834ab2-ec04-4d8b-bd36-310f89a199da + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 305 + 47 + 47 + 26 + + + 328.5 + 60.333332 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + a7380c0c-e690-4b7b-8b20-d2dd6945e4da + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 305 + 73 + 47 + 27 + + + 328.5 + 87 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 21a275d0-1f72-48ed-97d7-b2d5bae06a84 + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 305 + 100 + 47 + 26 + + + 328.5 + 113.666664 + + + + + + + + + + false + IyEgcHl0aG9uMwojIHJlcXVpcmVtZW50czogZGlmZkNoZWNrCgppbXBvcnQgU3lzdGVtCmltcG9ydCB0eXBpbmcKCmltcG9ydCBSaGlubwppbXBvcnQgUmhpbm8uR2VvbWV0cnkgYXMgcmcKCmZyb20gZ2hweXRob25saWIuY29tcG9uZW50YmFzZSBpbXBvcnQgZXhlY3V0aW5nY29tcG9uZW50IGFzIGNvbXBvbmVudAoKZnJvbSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcyBpbXBvcnQgREZWZXJ0ZXgsIERGRmFjZSwgREZCZWFtLCBERkFzc2VtYmx5CmltcG9ydCBkaWZmQ2hlY2suZGZfdHJhbnNmb3JtYXRpb25zCmltcG9ydCBkaWZmQ2hlY2suZGZfam9pbnRfZGV0ZWN0b3IKaW1wb3J0IGRpZmZDaGVjay5kZl91dGlsCgoKY2xhc3MgREZYTUxFeHBvcnRlcihjb21wb25lbnQpOgogICAgZGVmIFJ1blNjcmlwdChzZWxmLAogICAgICAgICAgICBpX2R1bXA6IGJvb2wsCiAgICAgICAgICAgIGlfYXNzZW1ibHlfbmFtZTogc3RyLAogICAgICAgICAgICBpX2V4cG9ydF9kaXI6IHN0ciwKICAgICAgICAgICAgaV9icmVwczogU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuSUxpc3RbUmhpbm8uR2VvbWV0cnkuQnJlcF0pOgogICAgICAgICIiIgogICAgICAgICAgICBUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zIDogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sIDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICAgICAgaWYgaV9kdW1wOgogICAgICAgICAgICBhc3NlbWJseTEuZHVtcCh4bWwsIGlfZXhwb3J0X2RpcikKICAgICAgICBvX3htbCA9IHhtbAoKICAgICAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgICAgICBvX2pvaW50cyA9IFtqZi50b19icmVwKCkgZm9yIGpmIGluIGFzc2VtYmx5MS5hbGxfam9pbnRfZmFjZXNdCiAgICAgICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10KCiAgICAgICAgcmV0dXJuIG9feG1sLCBvX2pvaW50cywgb19zaWRlcw== + S + + + + + *.*.python + 3.* + + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + 09820e90-22d3-463f-aeb1-e7a483ab60c9 + Brep + Brep + false + 0 + + + + + + 108 + 107 + 50 + 24 + + + 133.63321 + 119.357155 + + + + + + 1 + + + + + 6 + {0} + + + + + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 + + + + + aa56315b-2905-4049-8c41-0cc8b39d864b + + + + + 322f4e22-d195-435e-b290-052cb2318277 + + + + + 7fc04154-255a-413f-a8a1-6ea034e1e779 + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + aeae5255-2a74-4040-9e44-e3aedf934485 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 8c08df72-4af6-478d-b73d-4cb5062e929c + Button + dump! + false + 0 + + + + + + 53 + 46 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + db74a3b5-1227-46f8-823f-2e8caadc27f9 + File Path + Path + false + 0 + + + + + + 108 + 87 + 50 + 24 + + + 133.05814 + 99.121376 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 642efa41-dbbd-47ee-a53e-e1f51ffa1f12 + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 55 + 69 + 102 + 20 + + 0 + 0 + 0 + + 55.337097 + 69.41688 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 4646fc38-6159-4526-ae07-13f7dc4d54c6 + Custom Preview + Preview + + + + + + + 479 + 45 + 48 + 44 + + + 513 + 67 + + + + + + Geometry to preview + true + 086a1d3d-246b-49f6-a9b4-24689cf3e1fc + Geometry + G + false + a7380c0c-e690-4b7b-8b20-d2dd6945e4da + 1 + + + + + + 481 + 47 + 17 + 20 + + + 491 + 57 + + + + + + + + The material override + 3131a412-8e5e-44ab-883a-eaf4d47610d8 + Material + M + false + 4ab4fffe-a939-495b-828b-02fd527f45db + 1 + + + + + + 481 + 67 + 17 + 20 + + + 491 + 77 + + + + + + 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 + aa8c3345-4c0f-4f8d-a8da-af99adc98f83 + Custom Preview + Preview + + + + + + + 480 + 92 + 48 + 44 + + + 514 + 114 + + + + + + Geometry to preview + true + 15b754a7-39d2-46c6-ab6a-283c1e8ca0c6 + Geometry + G + false + 21a275d0-1f72-48ed-97d7-b2d5bae06a84 + 1 + + + + + + 482 + 94 + 17 + 20 + + + 492 + 104 + + + + + + + + The material override + 4a3b2a65-efde-445a-b243-524560892e32 + Material + M + false + d8ed0f8f-5311-4c4b-ae32-f035c085b9d5 + 1 + + + + + + 482 + 114 + 17 + 20 + + + 492 + 124 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 4ab4fffe-a939-495b-828b-02fd527f45db + Colour Swatch + Swatch + false + 0 + + 255;128;0;255 + + + + + + + 378 + 69 + 88 + 20 + + + 378.22855 + 69.73081 + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + d8ed0f8f-5311-4c4b-ae32-f035c085b9d5 + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 379 + 116 + 88 + 20 + + + 379.59103 + 116.77558 + + + + + + + + + + + + + + + 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 + + + + + \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index 44661b6a..dc58752b 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -6,8 +6,8 @@ from dataclasses import dataclass import df_util -import df_transformations -from df_geometries import DFFace +import diffCheck.df_transformations +from diffCheck.df_geometries import DFFace @dataclass class JointDetector(): @@ -37,10 +37,10 @@ def run(self) -> typing.List[DFFace]: # 1. Bring to XY, mamke AABB and get negative boolean difference ############################################################################ # bring to plane xy - x_form = df_transformations.pln_2_pln_world_transform(self.brep) + x_form = diffCheck.df_transformations.pln_2_pln_world_transform(self.brep) # reverse the transformation - x_form_back = df_transformations.get_inverse_transformation(x_form) + 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) diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py index 9b33557f..37cc41a1 100644 --- a/src/gh/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck_app.py @@ -8,11 +8,7 @@ import diffCheck -# import diffCheck.df_joint_detector # diffCheck. -import diffCheck.df_geometries # diffCheck. -# # from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly # diffCheck. -# # import diffCheck.df_transformations # diffCheck. -# # import diffCheck.df_util # diffCheck. +import diffCheck.df_geometries if __name__ == "__main__": diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index 97129e02..ae77b9b5 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 30 - -86 + 147 + -183 - 1.5 + 0.9211878 @@ -83,13 +83,13 @@ Robert McNeel & Associates 00000000-0000-0000-0000-000000000000 Grasshopper - 8.5.24072.13001 + 8.6.24101.5001 - RhinoCodePluginGH, Version=8.5.24072.13001, Culture=neutral, PublicKeyToken=552281e97c755530 - 8.5.24072.13001 + RhinoCodePluginGH, Version=8.6.24101.5001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.6.24101.5001 066d0a87-236f-4eae-a0f4-9e42f5327962 RhinoCodePluginGH @@ -111,7 +111,7 @@ - + true true @@ -120,11 +120,12 @@ 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 dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 - true - true - true + true + false + true script-sync cpython scsy-cpy + 1 false false @@ -198,7 +199,7 @@ true - No conversion + rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== @@ -211,7 +212,7 @@ 77c76654-6be3-4843-b564-afe44705740d 1 - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -269,7 +270,7 @@ true - No conversion + rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== @@ -282,7 +283,7 @@ 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 1 - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -351,7 +352,7 @@ true 0 The redirected standard output of the component scriptsync. - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -373,7 +374,7 @@ false - No conversion + rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== @@ -385,7 +386,7 @@ true 0 - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -407,7 +408,7 @@ false - No conversion + rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== @@ -419,7 +420,7 @@ true 0 - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -441,7 +442,7 @@ false - No conversion + rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== @@ -453,7 +454,7 @@ true 0 - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -475,7 +476,8 @@ - + + false #! python3
# r: numpy

from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name,
            i_dump: bool):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -1975,7 +1977,7 @@ - + true 2 @@ -1984,11 +1986,12 @@ 65e17a0f-52e4-4f2c-938f-4153c4d95177 true - true - true - true + true + false + true DFXMLExporter XMLout + 1 false false @@ -2075,7 +2078,7 @@ 66ce41af-42cf-48a0-871c-5d06b68b6ae7 1 The name of the assembly to export. - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -2111,7 +2114,7 @@ 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 1 The directors where to export the xml file. - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -2183,7 +2186,7 @@ true 0 The string of xml to be exported. - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -2218,7 +2221,7 @@ true 0 The breps of the faces belonging to joints. - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -2253,7 +2256,7 @@ true 0 The breps of the faces belonging to sides. - 6a184b65-baa3-42d1-a548-3915b401de53 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -2275,7 +2278,8 @@ - + + false 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 S @@ -2299,7 +2303,7 @@ - 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 + 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 From d1f4b028e2d3ef4ebf17ff9a7d5c26def5b82ec8 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 14:28:04 +0200 Subject: [PATCH 035/141] WIP: GlobalRegistration methods now static --- ...{registration.cc => globalregistration.cc} | 12 ++++---- ...{registration.hh => globalregistration.hh} | 18 +++++------- src/diffCheckApp.cc | 29 +++++++------------ 3 files changed, 25 insertions(+), 34 deletions(-) rename src/diffCheck/registration/{registration.cc => globalregistration.cc} (89%) rename src/diffCheck/registration/{registration.hh => globalregistration.hh} (68%) diff --git a/src/diffCheck/registration/registration.cc b/src/diffCheck/registration/globalregistration.cc similarity index 89% rename from src/diffCheck/registration/registration.cc rename to src/diffCheck/registration/globalregistration.cc index b2a65700..9f8e0577 100644 --- a/src/diffCheck/registration/registration.cc +++ b/src/diffCheck/registration/globalregistration.cc @@ -1,8 +1,8 @@ -#include "registration.hh" +#include "globalregistration.hh" namespace diffCheck::registration { - std::vector Registration::ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target) + std::vector GlobalRegistration::ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target) { std::vector errors; auto O3DSourcePointCloud = source->Cvt2O3DPointCloud(); @@ -13,7 +13,7 @@ namespace diffCheck::registration distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud); return distances; } - open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); @@ -39,7 +39,7 @@ namespace diffCheck::registration return result; } - open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); @@ -68,7 +68,7 @@ namespace diffCheck::registration return result; } - open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); @@ -94,7 +94,7 @@ namespace diffCheck::registration return result; } - open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/registration/registration.hh b/src/diffCheck/registration/globalregistration.hh similarity index 68% rename from src/diffCheck/registration/registration.hh rename to src/diffCheck/registration/globalregistration.hh index df1e5d53..ac5db32a 100644 --- a/src/diffCheck/registration/registration.hh +++ b/src/diffCheck/registration/globalregistration.hh @@ -3,13 +3,14 @@ #include "diffCheck.hh" #include -namespace diffCheck::registration{ +namespace diffCheck::registration +{ -class Registration +class GlobalRegistration //Must convert to static class { public: - std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); + static std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); /* Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html @@ -25,14 +26,14 @@ class Registration Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). */ - open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); + static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); /* Very little information on this registration method compared to the previous one. If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them. https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html */ - open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target); + static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target); /* Ransac registration based on correspondence: Correspondances are computed between the source and target point clouds. @@ -42,15 +43,12 @@ class Registration In practice, Open3D gives little information about the feature correspondence */ - open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target); + static open3d::pipelines::registration::RegistrationResult O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target); /* Ransac registration based on Feature Matching https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC */ - open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target); - - + static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target); - }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 503c2ed2..2333d619 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -31,7 +31,7 @@ int main() // add noise to dfPointCloudPtr for (int i = 0; i < dfPointCloudPtr->Points.size(); i++) { - dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01; + dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01 ; } std::vector timesFGRFeatureMatching; @@ -76,55 +76,52 @@ int iterations = 50; dfPointCloudPtrAfterTrans_3->Cvt2DFPointCloud(o3DPointCloudAfterTrans); dfPointCloudPtrAfterTrans_4->Cvt2DFPointCloud(o3DPointCloudAfterTrans); - - std::shared_ptr reg = std::make_shared(); - // Testing the Fast Global Registration on Feature Matching method std::shared_ptr dfPointCloudPtrAfterReg_1 = std::make_shared(); clock_t start_1 = clock(); - auto result_1 = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans_1, dfPointCloudPtr); + auto result_1 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_1, dfPointCloudPtr); double _intermediate_time_1 = (clock() - start_1) / (double) CLOCKS_PER_SEC; timesFGRFeatureMatching.push_back(_intermediate_time_1); Eigen::Matrix transformation = result_1.transformation_; std::shared_ptr o3DPointCloudPtrAfterReg_1 = std::make_shared(dfPointCloudPtrAfterTrans_1->Cvt2O3DPointCloud()->Transform(transformation)); dfPointCloudPtrAfterReg_1->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_1); - std::vector errors_1 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_1, dfPointCloudPtrGroundTruth); + std::vector errors_1 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_1, dfPointCloudPtrGroundTruth); errorsFGRFeatureMatching.push_back(std::accumulate(errors_1.begin(), errors_1.end(), 0.0) / errors_1.size()); // Testing the Fast Global Registration on Correspondance method std::shared_ptr dfPointCloudPtrAfterReg_2 = std::make_shared(); clock_t start_2 = clock(); - auto result_2 = reg->O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_2, dfPointCloudPtr); + auto result_2 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_2, dfPointCloudPtr); double _intermediate_time_2 = (clock() - start_2) / (double) CLOCKS_PER_SEC; timesFGRCorrespondance.push_back(_intermediate_time_2); Eigen::Matrix transformation_2 = result_2.transformation_; std::shared_ptr o3DPointCloudPtrAfterReg_2 = std::make_shared(dfPointCloudPtrAfterTrans_2->Cvt2O3DPointCloud()->Transform(transformation_2)); dfPointCloudPtrAfterReg_2->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_2); - std::vector errors_2 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_2, dfPointCloudPtrGroundTruth); + std::vector errors_2 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_2, dfPointCloudPtrGroundTruth); errorsFGRCorrespondance.push_back(std::accumulate(errors_2.begin(), errors_2.end(), 0.0) / errors_2.size()); // Testing the Ransac registration based on correspondance method std::shared_ptr dfPointCloudPtrAfterReg_3 = std::make_shared(); clock_t start_3 = clock(); - auto result_3 = reg->O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans_3, dfPointCloudPtr); + auto result_3 = diffCheck::registration::GlobalRegistration::O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans_3, dfPointCloudPtr); double _intermediate_time_3 = (clock() - start_3) / (double) CLOCKS_PER_SEC; timesRansacCorrespondance.push_back(_intermediate_time_3); Eigen::Matrix transformation_3 = result_3.transformation_; std::shared_ptr o3DPointCloudPtrAfterReg_3 = std::make_shared(dfPointCloudPtrAfterTrans_3->Cvt2O3DPointCloud()->Transform(transformation_3)); dfPointCloudPtrAfterReg_3->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_3); - std::vector errors_3 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_3, dfPointCloudPtrGroundTruth); + std::vector errors_3 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_3, dfPointCloudPtrGroundTruth); errorsRansacCorrespondance.push_back(std::accumulate(errors_3.begin(), errors_3.end(), 0.0) / errors_3.size()); // Testing the Ransac registration based on Feature Matching method std::shared_ptr dfPointCloudPtrAfterReg_4 = std::make_shared(); clock_t start_4 = clock(); - auto result_4 = reg->O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans_4, dfPointCloudPtr); + auto result_4 = diffCheck::registration::GlobalRegistration::O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans_4, dfPointCloudPtr); double _intermediate_time_4 = (clock() - start_4) / (double) CLOCKS_PER_SEC; timesRansacFeatureMatching.push_back(_intermediate_time_4); Eigen::Matrix transformation_4 = result_4.transformation_; std::shared_ptr o3DPointCloudPtrAfterReg_4 = std::make_shared(dfPointCloudPtrAfterTrans_4->Cvt2O3DPointCloud()->Transform(transformation_4)); dfPointCloudPtrAfterReg_4->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_4); - std::vector errors_4 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_4, dfPointCloudPtrGroundTruth); + std::vector errors_4 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_4, dfPointCloudPtrGroundTruth); errorsRansacFeatureMatching.push_back(std::accumulate(errors_4.begin(), errors_4.end(), 0.0) / errors_4.size()); std::cout<<"Iteration: "< Date: Fri, 12 Apr 2024 15:23:06 +0200 Subject: [PATCH 036/141] WIP: More precise names of classes added to diffcheck.hh --- src/diffCheck.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 1904a0f7..da8b35e8 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -8,4 +8,4 @@ #include "diffCheck/geometry/DFMesh.hh" #include "diffCheck/IOManager.hh" #include "diffCheck/visualizer.hh" -#include "diffCheck/registration/registration.hh" \ No newline at end of file +#include "diffCheck/registration/globalregistration.hh" \ No newline at end of file From c40590f95a2b1257bbb66493da061e577375b641 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 16:29:42 +0200 Subject: [PATCH 037/141] ADD: docstring documentation and registration parameters now parameters of the methods, not hard-coded --- src/diffCheck.hh | 2 +- .../registration/globalregistration.cc | 59 ++++++++++---- .../registration/globalregistration.hh | 78 ++++++++++++++++--- src/diffCheckApp.cc | 13 ---- 4 files changed, 112 insertions(+), 40 deletions(-) diff --git a/src/diffCheck.hh b/src/diffCheck.hh index da8b35e8..ad474536 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -8,4 +8,4 @@ #include "diffCheck/geometry/DFMesh.hh" #include "diffCheck/IOManager.hh" #include "diffCheck/visualizer.hh" -#include "diffCheck/registration/globalregistration.hh" \ No newline at end of file +#include "diffCheck/registration/globalRegistration.hh" \ No newline at end of file diff --git a/src/diffCheck/registration/globalregistration.cc b/src/diffCheck/registration/globalregistration.cc index 9f8e0577..a002303e 100644 --- a/src/diffCheck/registration/globalregistration.cc +++ b/src/diffCheck/registration/globalregistration.cc @@ -1,4 +1,4 @@ -#include "globalregistration.hh" +#include "globalRegistration.hh" namespace diffCheck::registration { @@ -13,7 +13,16 @@ namespace diffCheck::registration distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud); return distances; } - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, + std::shared_ptr target, + double voxelSize, + double radiusKDTreeSearch, + int maxNeighborKDTreeSearch, + double maxCorrespondenceDistance, + int iterationNumber, + int maxTupleCount) + + { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); @@ -22,9 +31,9 @@ namespace diffCheck::registration targetO3D->VoxelDownSample(0.01); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(0.25, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr option = std::make_shared(); option->maximum_correspondence_distance_ = 0.05; option->iteration_number_ = 100; @@ -39,7 +48,14 @@ namespace diffCheck::registration return result; } - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, + std::shared_ptr target, + double voxelSize, + double radiusKDTreeSearch, + int maxNeighborKDTreeSearch, + double maxCorrespondenceDistance, + int iterationNumber, + int maxTupleCount) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); @@ -53,9 +69,9 @@ namespace diffCheck::registration option->maximum_tuple_count_ = 500; std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); open3d::pipelines::registration::CorrespondenceSet correspondanceset; @@ -68,7 +84,13 @@ namespace diffCheck::registration return result; } - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr source, + std::shared_ptr target, + double voxelSize, + double radiusKDTreeSearch, + int maxNeighborKDTreeSearch, + double maxCorrespondenceDistance, + int correspondenceSetSize) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); @@ -77,9 +99,9 @@ namespace diffCheck::registration targetO3D->VoxelDownSample(0.01); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); open3d::pipelines::registration::CorrespondenceSet correspondanceset; @@ -88,13 +110,18 @@ namespace diffCheck::registration auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnCorrespondence(*sourceO3D, *targetO3D, correspondanceset, - 0.05, + maxCorrespondenceDistance, open3d::pipelines::registration::TransformationEstimationPointToPoint(), - 200); + correspondenceSetSize); return result; } - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target) + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr source, + std::shared_ptr target, + double voxelSize, + double radiusKDTreeSearch, + int maxNeighborKDTreeSearch, + double maxCorrespondenceDistance) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); @@ -103,15 +130,15 @@ namespace diffCheck::registration targetO3D->VoxelDownSample(0.01); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(3, 50)); + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D, *targetO3D, *sourceFPFHFeatures, *targetFPFHFeatures, false, - 0.05); + maxCorrespondenceDistance); return result; } diff --git a/src/diffCheck/registration/globalregistration.hh b/src/diffCheck/registration/globalregistration.hh index ac5db32a..7bc9c8c9 100644 --- a/src/diffCheck/registration/globalregistration.hh +++ b/src/diffCheck/registration/globalregistration.hh @@ -6,13 +6,14 @@ namespace diffCheck::registration { -class GlobalRegistration //Must convert to static class +class GlobalRegistration { public: - static std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); + static std::vector ComputeP2PDistance(std::shared_ptr source, + std::shared_ptr target); - /* + /** Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). @@ -25,16 +26,47 @@ class GlobalRegistration //Must convert to static class PCL's documentation refers to this 2009 TUM PhD thesis (but largely outside the scope of our work): https://mediatum.ub.tum.de/doc/800632/941254.pdf Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + + @param source the source point cloud + @param target the target point cloud + @param voxelSize the size of the voxels used to downsample the point clouds + @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + @param maxCorrespondenceDistance the maximum distance between correspondences. + @param iterationNumber the number of iterations to run the RanSaC registration algorithm + @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace */ - static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target); + static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, + std::shared_ptr target, + double voxelSize = 0.01, + double radiusKDTreeSearch = 3, + int maxNeighborKDTreeSearch = 50, + double maxCorrespondenceDistance = 0.05, + int iterationNumber = 100, + int maxTupleCount = 500); - /* + /** Very little information on this registration method compared to the previous one. If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them. https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html + + @param source the source point cloud + @param target the target point cloud + @param voxelSize the size of the voxels used to downsample the point clouds + @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + @param iterationNumber the number of iterations to run the RanSaC registration algorithm + @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace */ - static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target); - /* + static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, + std::shared_ptr target, + double voxelSize = 0.01, + double radiusKDTreeSearch = 3, + int maxNeighborKDTreeSearch = 50, + double maxCorrespondenceDistance = 0.05, + int iterationNumber = 100, + int maxTupleCount = 500); + /** Ransac registration based on correspondence: Correspondances are computed between the source and target point clouds. Then, a transformation is computed that minimizes the error between the correspondances. @@ -42,13 +74,39 @@ class GlobalRegistration //Must convert to static class In practice, Open3D gives little information about the feature correspondence + @param source the source point cloud + @param target the target point cloud + @param voxelSize the size of the voxels used to downsample the point clouds + @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + @param maxCorrespondenceDistance the maximum distance between correspondences. + @param correspondenceSetSize the number of correspondences to consider in the Ransac algorithm + */ - static open3d::pipelines::registration::RegistrationResult O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target); - /* + static open3d::pipelines::registration::RegistrationResult O3DRansacOnCorrespondence(std::shared_ptr source, + std::shared_ptr target, + double voxelSize = 0.01, + double radiusKDTreeSearch = 3, + int maxNeighborKDTreeSearch = 50, + double maxCorrespondenceDistance = 0.05, + int correspondenceSetSize = 200); + /** Ransac registration based on Feature Matching https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC + + @param source the source point cloud + @param target the target point cloud + @param voxelSize the size of the voxels used to downsample the point clouds + @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + @param maxCorrespondenceDistance the maximum distance between correspondences. */ - static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target); + static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr source, + std::shared_ptr target, + double voxelSize = 0.01, + double radiusKDTreeSearch = 3, + int maxNeighborKDTreeSearch = 50, + double maxCorrespondenceDistance = 0.05); }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 2333d619..d05a2561 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -139,19 +139,6 @@ int iterations = 50; devisu.Run(); } } - for (int i = 0; i < iterations; i++) - { - std::cout<<"Transformation: "< Date: Fri, 12 Apr 2024 16:48:49 +0200 Subject: [PATCH 038/141] WIP: remove automatic csv dump and fix small typo in globalRegistration.hh --- src/diffCheck/registration/globalregistration.hh | 4 ++-- src/diffCheckApp.cc | 6 ++++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/diffCheck/registration/globalregistration.hh b/src/diffCheck/registration/globalregistration.hh index 7bc9c8c9..f620b704 100644 --- a/src/diffCheck/registration/globalregistration.hh +++ b/src/diffCheck/registration/globalregistration.hh @@ -46,7 +46,7 @@ class GlobalRegistration int maxTupleCount = 500); /** - Very little information on this registration method compared to the previous one. + Little information on this registration method compared to the previous one. If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them. https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html @@ -72,7 +72,7 @@ class GlobalRegistration Then, a transformation is computed that minimizes the error between the correspondances. If the error is above a certain threshold, the transformation is discarded and a new one is computed. - In practice, Open3D gives little information about the feature correspondence + In practice, Open3D gives little information about the feature correspondence, compared to the FGR methods @param source the source point cloud @param target the target point cloud diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index d05a2561..e5275442 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -139,8 +139,8 @@ int iterations = 50; devisu.Run(); } } - - // write the errors and computation times to 2 csv files with one column per method + /* + // write the errors and computation times to 2 csv files with one column per method std::ofstream fileErrors("errors.csv"); std::ofstream fileTimes("times.csv"); fileErrors<<"FGR Feature Matching,FGR Correspondance,Ransac Correspondance,Ransac Feature Matching"< Date: Fri, 12 Apr 2024 16:51:47 +0200 Subject: [PATCH 039/141] REMOVE: plotter.py, as it is not needed anymore --- plotter.py | 26 -------------------------- 1 file changed, 26 deletions(-) delete mode 100644 plotter.py diff --git a/plotter.py b/plotter.py deleted file mode 100644 index 105f5328..00000000 --- a/plotter.py +++ /dev/null @@ -1,26 +0,0 @@ -import numpy as np -import matplotlib.pyplot as plt - -def main(): - # open csv file - time_data = np.genfromtxt('times.csv', delimiter=',', skip_header=1) - error_data = np.genfromtxt('errors.csv', delimiter=',', skip_header=1) - x = np.linspace(1, len(time_data), len(time_data)) - plt.plot(x, time_data) - plt.xlabel('Iteration') - plt.ylabel('Time [s]') - plt.title('Time vs Iteration: additive 00') - plt.legend(["FGR Feature Matching","FGR Correspondance","Ransac Correspondance","Ransac Feature Matching"]) - plt.show() - - - plt.plot(x, error_data) - plt.xlabel('Iteration') - plt.ylabel('Mean error [mm]') - plt.title('Error vs Iteration: additive 00') - plt.legend(["FGR Feature Matching","FGR Correspondance","Ransac Correspondance","Ransac Feature Matching"]) - plt.show() - - -if __name__ == '__main__': - main() \ No newline at end of file From 0534d67a7cd298272f43b6b4950b0a6d083b96ee Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:08:33 +0200 Subject: [PATCH 040/141] WIP removed .vscode file --- .vscode/settings.json | 101 ------------------------------------------ 1 file changed, 101 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 26812044..00000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,101 +0,0 @@ -{ - "files.associations": { - "iostream": "cpp", - "string": "cpp", - "algorithm": "cpp", - "array": "cpp", - "atomic": "cpp", - "bit": "cpp", - "cctype": "cpp", - "charconv": "cpp", - "chrono": "cpp", - "clocale": "cpp", - "cmath": "cpp", - "compare": "cpp", - "concepts": "cpp", - "cstddef": "cpp", - "cstdint": "cpp", - "cstdio": "cpp", - "cstdlib": "cpp", - "cstring": "cpp", - "ctime": "cpp", - "cwchar": "cpp", - "exception": "cpp", - "filesystem": "cpp", - "format": "cpp", - "forward_list": "cpp", - "functional": "cpp", - "initializer_list": "cpp", - "iomanip": "cpp", - "ios": "cpp", - "iosfwd": "cpp", - "istream": "cpp", - "iterator": "cpp", - "limits": "cpp", - "list": "cpp", - "locale": "cpp", - "map": "cpp", - "memory": "cpp", - "new": "cpp", - "optional": "cpp", - "ostream": "cpp", - "ratio": "cpp", - "sstream": "cpp", - "stdexcept": "cpp", - "streambuf": "cpp", - "system_error": "cpp", - "tuple": "cpp", - "type_traits": "cpp", - "typeindex": "cpp", - "typeinfo": "cpp", - "unordered_map": "cpp", - "unordered_set": "cpp", - "utility": "cpp", - "vector": "cpp", - "xfacet": "cpp", - "xhash": "cpp", - "xiosbase": "cpp", - "xlocale": "cpp", - "xlocbuf": "cpp", - "xlocinfo": "cpp", - "xlocmes": "cpp", - "xlocmon": "cpp", - "xlocnum": "cpp", - "xloctime": "cpp", - "xmemory": "cpp", - "xstddef": "cpp", - "xstring": "cpp", - "xtr1common": "cpp", - "xtree": "cpp", - "xutility": "cpp", - "any": "cpp", - "complex": "cpp", - "condition_variable": "cpp", - "csignal": "cpp", - "cstdarg": "cpp", - "deque": "cpp", - "execution": "cpp", - "fstream": "cpp", - "future": "cpp", - "mutex": "cpp", - "numeric": "cpp", - "queue": "cpp", - "random": "cpp", - "regex": "cpp", - "set": "cpp", - "span": "cpp", - "stop_token": "cpp", - "thread": "cpp", - "variant": "cpp", - "bitset": "cpp", - "cfenv": "cpp", - "ranges": "cpp", - "shared_mutex": "cpp", - "source_location": "cpp", - "stack": "cpp", - "valarray": "cpp", - "*.inc": "cpp", - "coroutine": "cpp", - "resumable": "cpp" - } -} \ No newline at end of file From f63dc6e28065da1155122b27b61a6e9aa772ff23 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:15:12 +0200 Subject: [PATCH 041/141] ADD: refinedRegistration files to create PR --- src/diffCheck/registration/refinedRegistration.cc | 1 + src/diffCheck/registration/refinedRegistration.hh | 0 2 files changed, 1 insertion(+) create mode 100644 src/diffCheck/registration/refinedRegistration.cc create mode 100644 src/diffCheck/registration/refinedRegistration.hh diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc new file mode 100644 index 00000000..8c788329 --- /dev/null +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -0,0 +1 @@ +#include "refinedRegistration.hh" diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh new file mode 100644 index 00000000..e69de29b From fdd77be0d9a2026cbc2178fd1902c12ca05742c5 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 14 Apr 2024 13:53:17 +0200 Subject: [PATCH 042/141] ADD: link to badge pypi --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 5927947b..df89009e 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@

- +

From 49afd579377a440dc411e17d8d4c77751f1fcf6e Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 15 Apr 2024 11:15:56 +0200 Subject: [PATCH 043/141] WIP-FIX: solved circular import problem --- deps/eigen | 2 +- examples/exporter.ghx | 8 +- src/gh/components/DF_xml_exporter/code.py | 23 +- src/gh/diffCheck/diffCheck/__init__.py | 2 +- src/gh/diffCheck/diffCheck/df_geometries.py | 80 +- .../diffCheck/diffCheck/df_joint_detector.py | 34 +- .../diffCheck/diffCheck/df_transformations.py | 35 +- src/gh/diffCheck/diffCheck/df_util.py | 9 +- src/gh/diffCheck/diffCheck/diffCheck_app.py | 40 + src/gh/diffCheck/diffCheck_app.py | 42 - src/gh/diffCheck/setup.py | 28 +- src/gh/tester.ghx | 1817 ++++++++++++++--- 12 files changed, 1741 insertions(+), 379 deletions(-) create mode 100644 src/gh/diffCheck/diffCheck/diffCheck_app.py delete mode 100644 src/gh/diffCheck/diffCheck_app.py diff --git a/deps/eigen b/deps/eigen index 5226566a..9099c5ea 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 5226566a14ddb4d84214c40809531038f087d187 +Subproject commit 9099c5eac756ff44cf901b4cd31e08ad2efda46b diff --git a/examples/exporter.ghx b/examples/exporter.ghx index b56dfb0d..983270d9 100644 --- a/examples/exporter.ghx +++ b/examples/exporter.ghx @@ -49,10 +49,10 @@ - 176 - 84 + 84 + 292 - 1.2750005 + 1.2750001 @@ -957,7 +957,7 @@ - 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 + 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 diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py index 7a3905d9..38ba2b10 100644 --- a/src/gh/components/DF_xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -1,5 +1,5 @@ #! python3 -# requirements: diffCheck +# r: diffCheck==0.0.8 import System import typing @@ -9,19 +9,16 @@ from ghpythonlib.componentbase import executingcomponent as component -from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly -import diffCheck.df_transformations -import diffCheck.df_joint_detector -import diffCheck.df_util +import diffCheck +from diffCheck.df_geometries import DFBeam, DFAssembly class DFXMLExporter(component): def RunScript(self, - i_dump : bool, - i_assembly_name : str, - i_export_dir : str, - i_breps : typing.List[Rhino.Geometry.Brep] - ): + i_dump: bool, + i_assembly_name, + i_export_dir, + i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep]): """ This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them to XML. @@ -30,7 +27,7 @@ def RunScript(self, :param i_breps: list of breps """ # beams - beams : typing.List[DFBeam] = [] + beams: typing.List[DFBeam] = [] for brep in i_breps: beam = DFBeam.from_brep(brep) beams.append(beam) @@ -39,9 +36,9 @@ def RunScript(self, assembly1 = DFAssembly(beams, i_assembly_name) # dump the xml - xml : str = assembly1.to_xml() + xml: str = assembly1.to_xml() if i_dump: - assembly1.dump(xml, i_export_dir) + assembly1.dump_xml(xml, i_export_dir) o_xml = xml # show the joint/side faces diff --git a/src/gh/diffCheck/diffCheck/__init__.py b/src/gh/diffCheck/diffCheck/__init__.py index 8dbfdadd..71eb32d8 100644 --- a/src/gh/diffCheck/diffCheck/__init__.py +++ b/src/gh/diffCheck/diffCheck/__init__.py @@ -1 +1 @@ -__version__ = '0.0.3' \ No newline at end of file +__version__ = "0.0.8" \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index a869149d..47dbff55 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -18,9 +18,11 @@ class DFVertex: """ This class represents a vertex, a simple container with 3 coordinates """ - x : float - y : float - z : float + + x: float + y: float + z: float + def __post_init__(self): self.x = self.x or 0.0 self.y = self.y or 0.0 @@ -61,15 +63,17 @@ class DFFace: """ This class represents a face, in diffCheck, a face is a collection of vertices. """ + # just as breps a first outer loop and then inner loops of DFVertices - all_loops : typing.List[typing.List[DFVertex]] - joint_id : int + all_loops: typing.List[typing.List[DFVertex]] + joint_id: int = None + def __post_init__(self): if len(self.all_loops[0]) < 3: raise ValueError("A face must have at least 3 vertices") - self.all_loops = self.all_loops or [] + self.all_loops = self.all_loops - self.joint_id = self.joint_id or None + self.joint_id = self.joint_id self.__is_joint = False self.__id = uuid.uuid4().int @@ -77,8 +81,14 @@ def __repr__(self): return f"Face id: {len(self.id)}, IsJoint: {self.is_joint} Loops: {len(self.all_loops)}" def __hash__(self): - outer_loop = tuple(tuple(vertex.__dict__.values()) for vertex in self.all_loops[0]) - inner_loops = tuple(tuple(vertex.__dict__.values()) for loop in self.all_loops[1:] for vertex in loop) + outer_loop = tuple( + tuple(vertex.__dict__.values()) for vertex in self.all_loops[0] + ) + inner_loops = tuple( + tuple(vertex.__dict__.values()) + for loop in self.all_loops[1:] + for vertex in loop + ) return hash((outer_loop, inner_loops)) def __eq__(self, other): @@ -86,21 +96,8 @@ def __eq__(self, other): return self.all_loops == other.all_loops return False - @staticmethod - def compute_mass_center(face: rg.BrepFace) -> rg.Point3d: - """ - Compute the mass center of a face - - :param face: The face to compute the mass center from - :return mass_center: The mass center of the face - """ - amp = rg.AreaMassProperties.Compute(face) - if amp: - return amp.Centroid - return None - @classmethod - def from_brep(cls, brep_face: rg.BrepFace, joint_id: int=None): + def from_brep(cls, brep_face: rg.BrepFace, joint_id: int = None): """ Create a DFFace from a Rhino Brep face @@ -135,12 +132,16 @@ def to_brep(self): brep_curves = [] for loop in self.all_loops: - inner_vertices = [rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in loop] + inner_vertices = [ + rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in loop + ] inner_polyline = rg.Polyline(inner_vertices) inner_curve = inner_polyline.ToNurbsCurve() brep_curves.append(inner_curve) - brep = rg.Brep.CreatePlanarBreps(brep_curves, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)[0] + brep = rg.Brep.CreatePlanarBreps( + brep_curves, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance + )[0] return brep @@ -171,8 +172,10 @@ class DFBeam: """ This class represents a beam, in diffCheck, a beam is a collection of faces """ - name : str - faces : typing.List[DFFace] + + name: str + faces: typing.List[DFFace] + def __post_init__(self): self.name = self.name or "Unnamed Beam" self.faces = self.faces or [] @@ -187,8 +190,11 @@ def from_brep(cls, brep): Create a DFBeam from a RhinoBrep object. It also removes duplicates and creates a list of unique faces. """ - faces = diffCheck.df_joint_detector.JointDetector(brep).run() - faces = list(set(faces)) + 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]) + faces.append(face) beam = cls("Beam", faces) return beam @@ -213,8 +219,10 @@ class DFAssembly: """ This class represents an assembly of beams """ - beams : typing.List[DFBeam] - name : str + + beams: typing.List[DFBeam] + name: str + def __post_init__(self): self.beams = self.beams self.name = self.name or "Unnamed Assembly" @@ -256,7 +264,9 @@ def to_xml(self): mesh = face.to_mesh() mesh_vertices = mesh.Vertices for idx, vertex in enumerate(mesh_vertices): - facerhmesh_vertex_elem = ET.SubElement(facerhmesh_elem, "RhMeshVertex") + facerhmesh_vertex_elem = ET.SubElement( + facerhmesh_elem, "RhMeshVertex" + ) facerhmesh_vertex_elem.set("x", str(vertex.X)) facerhmesh_vertex_elem.set("y", str(vertex.Y)) facerhmesh_vertex_elem.set("z", str(vertex.Z)) @@ -269,13 +279,13 @@ def to_xml(self): facerhmesh_face_elem.set("v4", str(face.D)) tree = ET.ElementTree(root) - xml_string = ET.tostring(root, encoding='unicode') + xml_string = ET.tostring(root, encoding="unicode") dom = parseString(xml_string) pretty_xml = dom.toprettyxml() return pretty_xml - def dump_xml(self, pretty_xml : str, dir: str): + def dump_xml(self, pretty_xml: str, dir: str): """ Dump the pretty XML to a file @@ -298,4 +308,4 @@ def all_joint_faces(self): def all_side_faces(self): for beam in self.beams: self._all_sidefaces.extend(beam.side_faces) - return self._all_sidefaces \ No newline at end of file + return self._all_sidefaces diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index dc58752b..7546819e 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -5,12 +5,12 @@ import typing from dataclasses import dataclass -import df_util +import diffCheck.df_util import diffCheck.df_transformations -from diffCheck.df_geometries import DFFace + @dataclass -class JointDetector(): +class JointDetector: """ This class is responsible for detecting joints in a brep """ @@ -25,9 +25,21 @@ def __post_init__(self): self._mix : typing.List[rg.Brep]= [] # list of DFFaces from joints and sides - self._faces : typing.List[DFFace] = [] + self._faces = [] + + def _compute_mass_center(self, b_face: rg.BrepFace) -> rg.Point3d: + """ + Compute the mass center of a brep face + + :param b_face: The brep face to compute the mass center from + :return mass_center: The mass center of the brep face + """ + amp = rg.AreaMassProperties.Compute(b_face) + if amp: + return amp.Centroid + return None - def run(self) -> typing.List[DFFace]: + def run(self) : """ Run the joint detector @@ -73,7 +85,7 @@ def run(self) -> typing.List[DFFace]: is_cut = False is_hole = True - b_faces = df_util.explode_brep(b) + 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 @@ -109,7 +121,7 @@ def run(self) -> typing.List[DFFace]: # (5) check if closed, if it is # ---------------------- # (1) explode - faces_b = df_util.explode_brep(b) + 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 = [] @@ -164,23 +176,23 @@ def run(self) -> typing.List[DFFace]: idx = idx + 1 temp_face_centroids = [] for f in b.Faces: - centroid = DFFace.compute_mass_center(f) + centroid = self._compute_mass_center(f) temp_face_centroids.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 = DFFace.compute_mass_center(f) + 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(DFFace.from_brep(f, key)) + self._faces.append([f, key]) is_joint = True break if is_joint: break if not is_joint: - self._faces.append(DFFace.from_brep(f, None)) + self._faces.append([f, None]) 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 7e3b434c..c72adb1c 100644 --- a/src/gh/diffCheck/diffCheck/df_transformations.py +++ b/src/gh/diffCheck/diffCheck/df_transformations.py @@ -4,19 +4,24 @@ import numpy as np -def get_inverse_transformation(x_form : Rhino.Geometry.Transform) -> Rhino.Geometry.Transform: + +def get_inverse_transformation( + x_form: Rhino.Geometry.Transform, +) -> Rhino.Geometry.Transform: """ Get the inverse of a transformation :param x_form: the transformation to get the inverse from :return: the inverse transformation """ - transformation_matrix = np.array([ - [x_form.M00, x_form.M01, x_form.M02, x_form.M03], - [x_form.M10, x_form.M11, x_form.M12, x_form.M13], - [x_form.M20, x_form.M21, x_form.M22, x_form.M23], - [x_form.M30, x_form.M31, x_form.M32, x_form.M33] - ]) + transformation_matrix = np.array( + [ + [x_form.M00, x_form.M01, x_form.M02, x_form.M03], + [x_form.M10, x_form.M11, x_form.M12, x_form.M13], + [x_form.M20, x_form.M21, x_form.M22, x_form.M23], + [x_form.M30, x_form.M31, x_form.M32, x_form.M33], + ] + ) inverse_transformation_matrix = np.linalg.inv(transformation_matrix) x_form_back = Rhino.Geometry.Transform() @@ -26,13 +31,15 @@ def get_inverse_transformation(x_form : Rhino.Geometry.Transform) -> Rhino.Geome return x_form_back -def pln_2_pln_world_transform(brep : Rhino.Geometry.Brep) -> Rhino.Geometry.Transform: + +def pln_2_pln_world_transform(brep: Rhino.Geometry.Brep) -> Rhino.Geometry.Transform: """ Transform a brep (beam) to the world plane :param brep: the brep to transform :return: the transformation """ + def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: """ Get the the vertex with the lowest y,x and z values @@ -71,7 +78,7 @@ def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: if rg.AreaMassProperties.Compute(face).Area > biggest_face_area: biggest_face_area = rg.AreaMassProperties.Compute(face).Area biggest_face = face - + # get the plane of the biggest face if biggest_face.TryGetPlane()[0] is False: log.error("Could not find plane for longest edge. Exiting...") @@ -105,11 +112,15 @@ def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: print("Bounding box is alligned to x axis. No rotation needed.") else: print("Bounding box is not alligned to y axis. A 90 deg rotation is needed.") - x_form_rot90z = Rhino.Geometry.Transform.Rotation(math.radians(90), rg.Vector3d.ZAxis, rg.Point3d.Origin) + x_form_rot90z = Rhino.Geometry.Transform.Rotation( + math.radians(90), rg.Vector3d.ZAxis, rg.Point3d.Origin + ) brep.Transform(x_form_rot90z) lowest_vertex = _get_lowest_brep_vertex(brep) - x_form_transl_B = Rhino.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) + x_form_transl_B = Rhino.Geometry.Transform.Translation( + rg.Vector3d(-lowest_vertex) + ) brep.Transform(x_form_transl_B) # resume the transformations in one @@ -120,4 +131,4 @@ def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: x_form = x_form_transl_B * x_form_rot90z x_form = x_form * x_form_transl_A * x_form_pln2pln - return x_form \ No newline at end of file + return x_form diff --git a/src/gh/diffCheck/diffCheck/df_util.py b/src/gh/diffCheck/diffCheck/df_util.py index bae262c9..0ccf3a0a 100644 --- a/src/gh/diffCheck/diffCheck/df_util.py +++ b/src/gh/diffCheck/diffCheck/df_util.py @@ -21,6 +21,7 @@ def explode_brep(brep) -> typing.List[Rhino.Geometry.Brep]: exploded_objects.append(face_brep) return exploded_objects + def get_crv_circle_center(crv) -> rg.Point3d: """ Get the center of a circle """ bbox = crv.GetBoundingBox(True) @@ -28,6 +29,7 @@ def get_crv_circle_center(crv) -> rg.Point3d: center_point = bbox_b.GetBoundingBox(True).Center return center_point + def is_pt_unique_in_dict(pt, pt_dict) -> bool: """ Detect if the point exists in the dictionary, and if so, return the index @@ -51,6 +53,7 @@ def is_pt_unique_in_dict(pt, pt_dict) -> bool: break return is_unique + def is_pt_unique_in_list(pt, list) -> bool: """ Detect if the point exists in the list, and if so, return the index @@ -74,6 +77,7 @@ def is_pt_unique_in_list(pt, list) -> bool: break return is_unique + def detect_idx_pt_in_list(pt, list) -> int: """ Detect the index of a point in a list @@ -97,6 +101,7 @@ def detect_idx_pt_in_list(pt, list) -> int: return idx return idx + def compute_ordered_vertices(brep_face) -> typing.List[Rhino.Geometry.Point3d]: """ Retrieve the ordered vertices of a brep face """ sorted_vertices = [] @@ -127,8 +132,8 @@ def compute_ordered_vertices(brep_face) -> typing.List[Rhino.Geometry.Point3d]: edges_sorted.append(edge) edges.pop(edges.index(edge)) break - + for edge in edges_sorted: sorted_vertices.append(edge.PointAtStart) - return sorted_vertices \ No newline at end of file + return sorted_vertices diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py new file mode 100644 index 00000000..fd5a9264 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -0,0 +1,40 @@ +#! python3 + +import Rhino +import Rhino.Geometry as rg + +import os +import typing + +import diffCheck +import diffCheck.df_util +from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly + +import diffCheck.df_joint_detector + +if __name__ == "__main__": + """ + Main function to test the package + :param i_breps: list of breps + :param i_export_dir: directory to export the xml + :param i_dump: whether to dump the xml + """ + # beams + beams = [] + for brep in i_breps: + beam = DFBeam.from_brep(brep) + print(beam) + 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] diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py deleted file mode 100644 index 37cc41a1..00000000 --- a/src/gh/diffCheck/diffCheck_app.py +++ /dev/null @@ -1,42 +0,0 @@ -#! python3 - -import Rhino -import Rhino.Geometry as rg - -import os -import typing - -import diffCheck - -import diffCheck.df_geometries - - -if __name__ == "__main__": - joint_detector = diffCheck.df_joint_detector.JointDetector(brep=i_breps[0]).run() - print(type(joint_detector)) - # print(joint_detector.run()) - beam = diffCheck.df_geometries.DFBeam.from_brep(i_breps[0]) - """ - Main function to test the package - :param i_breps: list of breps - :param i_export_dir: directory to export the xml - :param i_dump: whether to dump the xml - """ - # beams - beams : typing.List[diffCheck.df_geometries.DFBeam] = [] - for brep in i_breps: - beam = diffCheck.df_geometries.DFBeam.from_brep(brep) - beams.append(beam) - - # assembly - assembly1 = diffCheck.df_geometries.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] \ No newline at end of file diff --git a/src/gh/diffCheck/setup.py b/src/gh/diffCheck/setup.py index 3520ee6a..331e6e6a 100644 --- a/src/gh/diffCheck/setup.py +++ b/src/gh/diffCheck/setup.py @@ -1,18 +1,22 @@ from setuptools import setup, find_packages setup( - name='diffCheck', - version='0.0.3', + name="diffCheck", + version="0.0.8", packages=find_packages(), - description='DiffCheck is a package to check the differences between two timber structures', - long_description=open('README.md').read(), - long_description_content_type='text/markdown', - author='Andrea Settimi, Damien Gilliard, Eleni Skevaki, Marirena Kladeftira, Julien Gamerro, Stefana Parascho, and Yves Weinand', - author_email='andrea.settimi@epfl.ch', - url='https://github.com/diffCheckOrg/diffCheck', + install_requires=[ + "numpy", + # other dependencies... + ], + description="DiffCheck is a package to check the differences between two timber structures", + long_description=open("README.md").read(), + long_description_content_type="text/markdown", + author="Andrea Settimi, Damien Gilliard, Eleni Skevaki, Marirena Kladeftira, Julien Gamerro, Stefana Parascho, and Yves Weinand", + author_email="andrea.settimi@epfl.ch", + url="https://github.com/diffCheckOrg/diffCheck", classifiers=[ - 'License :: OSI Approved :: MIT License', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.7', + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", ], -) \ No newline at end of file +) diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index ae77b9b5..d3676569 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 147 - -183 + 163 + -418 - 0.9211878 + 0.92118883 @@ -69,7 +69,7 @@ - F:\diffCheck\src\gh\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck\diffCheck_app.py F:\diffCheck\src\gh\diffCheck\diffCheck\test.py @@ -100,9 +100,9 @@ - 25 + 37 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -114,12 +114,12 @@ true - true 2 iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABhmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTtIw1AUhv+mSkUqDhZ84JChCoIFURFHiWIRLJS2QqsOJjd9QZOGJMXFUXAtOPhYrDq4OOvq4CoIgg8QZwcnRRcp8dyk0CJU8MDlfvz3/j/nngsItRLTrI4JQNNtMxGVxHRmVQy8wodB9EPAmMwsI5ZcTKFtfd3Tbaq7CM/C/6pHzVoM8InEc8wwbeIN4plN2+C8TxxiBVklPiceN6lB4keuKx6/cc67LPDMkJlKzBOHiMV8CystzAqmRjxNHFY1nfKFtMcq5y3OWqnCGn3yFwaz+kqS67SGEcUSYohDhIIKiijBRoR2nRQLCTqX2viHXH+cXAq5imDkWEAZGmTXD/4Hv2dr5aYmvaSgBHS+OM7HCBDYBepVx/k+dpz6CeB/Bq70pr9cA2Y/Sa82tfAR0LsNXFw3NWUPuNwBBp4M2ZRdyU9LyOWA9zP6pgzQdwt0r3lza5zj9AFI0ayWb4CDQ2A0T9nrbd7d1Tq3P++484P0A3o2cqrMnZbPAAAACXBIWXMAAAsMAAALDAE/QCLIAAAAB3RJTUUH6AEZFwkM569AfQAABNpJREFUSEu9kntMU3cYhguoOOZ1ujmFXqQtBcEpIwoTxOGQolLwUp24OFS0sEqh0oIV0CIg1FLKsbTlNooFKhRF8TajziW6zYFxcckW9bhlm9uiLk6nAyuWy7tTc0iI4w9l2Z7k++/7nveX9xzGfw+LWMhgV4hd48Y2iN1ZBvEoFiH2ZOrFXkydeJzPvsn05ghhmxIZnCq4xo1TCXe2GaPZJniyKvAqi8AEps5Eb/4LOJVfDQZ4PAswYizLgHHMckxi6vqmeJfMpjdHCNscQgUMDAaMoQJeoQLGUwGTfXR43bvkM3pz5LhxzHXuVMAoqp4x7Ap4sfZT9ejxmk8ppnlrEDE142bCxA3k2vHryKSZYnJrcPxS+vTFcGMR09w55keuAFf/Xs/612OKjxZvepdAMF2NFROT8IHv+5CEroZskeiaJC7Cgz5/MTzYRsVg/64PPJFZhqlUwHTvYrBmFGBZsAybw9ZCGr0SyhXLoVobk0Gfvhju/CJPD2GnY7SwE57CDngJL2FCzBeYsuQC/OM/Rdiq45AsWQP5ygSoEpdi94fRDyslc6SWNH9pvVwgtWb7SQ/k8CfRumHY2ithpACD45YyAA9JP3ykPQiQdSNh4zlsS1gFZaIIuZuEKEx5DwZZKKyZAWhUCdC0i5o9fIK2Pcfm7gmMlIF7zwd4b3MiMMOBhdvvQLJ6C+TrV0CVvBz5qTEoTo+CThmBAzlBaNotgK3AD80av97mUt4s2joESX/ZULlr3pD2I1Deg/nKLiQmN0O2Xoys5HjsksaiUB6Nfcp3UZ67ANX5IThYRMn38dFSxoed4J+lrTRbngio1zuHyid9NABeei+CFQ5EZ91FcsZZyBTtUGUfRGFuLXRqAuaCEtQX51GvlqCllBLr+Wg18HDIzIO9xnc5baeQ9J0YKncNU9aPOYoeLNzZhXWZV5CiOI3MHW3Iy21AsboSRIEe1ZpCNGh3okUXjhaCkhspeRUPh2u5aLNwb1isM0a7Xi98Xj49rR8CuRPvqBxYtuNXbFKcR5rqBLLz7MjPt0BbZIRRo0WdLh82fRLs+/k4ZKLk1ZT4Yy6O1FPT6IujzTMzqT/HGUv1nzp0eOnO1JAsR+rinPuZiYrOPonqLOS57chRH8TevbUo01D16IrRSOSgwxCJK6ZgXK2ZjW/rZuGa1Q+kjYfvW7i40ep7ne5oeNbIL6mTsi9gW95pKNVtUBc1QKOpwn5dGarLC3GxYiN+Mkfgds183LcEo8sahB6bP3rtfAwc5qK3nbORVv0TUdpF1jplx+OtueeRvvskVIV2FJTUQ1tqgpHQotm4EzeMi3GrKhx36+bhgXUuum2B6LEL0NfGQ/8x38u0anhWbe/Yu0H1OZm66wyZuecomVfSRBZpa0h9OUGaK4rJL43rcbN6EX6xhOF3awge2mbjcWsAnrb5oe84F49PcUJp1ctz2SCM+64qGj/URuK3A6G4Z5uLR/YgONoEcB7jwXlqZiO9+vKcIaLHfG2KJa/VLMaPlnDcts3DHy1z8NfhQDxp96Pk3O77Z9gz6PWXp7MiTnG1MhbX66Lwc8MC3GkOwYNDb6GrPQA9J/lwnPbNo1dHRqdJFPVNbYyItEaKbjWFie62vi3680iQqPu4v+jpJzzRg3PssfTq/wGD8Tedsdp6457pjwAAAABJRU5ErkJggg== dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 + true true false true @@ -135,13 +135,13 @@ - 175 + 177 92 171 104 - 282 + 284 144 @@ -162,13 +162,14 @@ - + true Connect a button to open a file dialog to select a cpython file to run. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= 083c2fe3-a45a-43c1-8f85-ce20a4a69a99 + true btn btn true @@ -183,13 +184,13 @@ - 177 + 179 94 90 20 - 223.5 + 225.5 104 @@ -197,13 +198,14 @@ - + true rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== e0ef2066-70a4-441f-906b-8a4afddb0692 + true i_export_dir i_export_dir true @@ -218,13 +220,13 @@ - 177 + 179 114 90 20 - 223.5 + 225.5 124 @@ -232,7 +234,7 @@ - + 1 true Converts to collection of Breps (Boundary REPresentations) @@ -240,6 +242,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= ae8c9c0d-8d6a-4a8c-812a-110846a2031c + true i_breps i_breps true @@ -254,13 +257,13 @@ - 177 + 179 134 90 20 - 223.5 + 225.5 144 @@ -268,13 +271,14 @@ - + true rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== d9632669-508e-4a03-b9bc-a5d740ef546f + true i_assembly_name i_assembly_name true @@ -289,13 +293,13 @@ - 177 + 179 154 90 20 - 223.5 + 225.5 164 @@ -303,13 +307,14 @@ - + true Converts to collection of boolean values iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC 1e3c2c63-ede9-4faf-9790-a3d1b9350ba3 + true i_dump i_dump true @@ -324,13 +329,13 @@ - 177 + 179 174 90 20 - 223.5 + 225.5 184 @@ -338,13 +343,14 @@ - + false The redirected standard output of the component scriptsync. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 + true stdout stdout false @@ -358,13 +364,13 @@ - 297 + 299 94 47 25 - 320.5 + 322.5 106.5 @@ -372,13 +378,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== a849584f-8d8a-4547-a1a4-36be0bf3ac37 + true o_xml o_xml false @@ -392,13 +399,13 @@ - 297 + 299 119 47 25 - 320.5 + 322.5 131.5 @@ -406,13 +413,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 178951a0-3c74-4810-aef0-87cc45b0502c + true o_joints o_joints false @@ -426,13 +434,13 @@ - 297 + 299 144 47 25 - 320.5 + 322.5 156.5 @@ -440,13 +448,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 76758d37-2a1d-412d-b85b-149ecda8a020 + true o_sides o_sides false @@ -460,13 +469,13 @@ - 297 + 299 169 47 25 - 320.5 + 322.5 181.5 @@ -501,11 +510,12 @@ - + Button object with two values False True 5f8bfbf4-70d5-46ba-90fa-f3804e9a9032 + true Button false @@ -533,10 +543,11 @@ - + Contains a collection of Breps (Boundary REPresentations) true 0f309845-29e6-43ae-b255-cdb5c2d13da9 + true Brep Brep false @@ -564,40 +575,18 @@ - 6 + 1 {0} - + - - ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 - - - - - aa56315b-2905-4049-8c41-0cc8b39d864b - - - - - 322f4e22-d195-435e-b290-052cb2318277 - - - - - 7fc04154-255a-413f-a8a1-6ea034e1e779 - - - - + + + 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 + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 - - - aeae5255-2a74-4040-9e44-e3aedf934485 - - @@ -613,13 +602,14 @@ - + A panel for custom notes and text values 6ffd83cc-a073-46cd-8213-4c0663708aa7 + true Panel false - 0.8518518507480621 + 1 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 1 Double click to edit panel content… @@ -629,16 +619,16 @@ 445 - -256 + -189 494 - 292 + 251 0 0 0 445.17487 - -255.70482 + -188.04263 @@ -666,61 +656,10 @@ - - A panel for custom notes and text values - d5d04f93-3b13-4fa3-8644-243c03f9a7e8 - Panel - - false - 0.2985713966190815 - 0 - Double click to edit panel content… - - - - - - 445 - 295 - 118 - 183 - - 0 - 0 - 0 - - 445.13605 - 295.23444 - - - - - - - 255;213;217;232 - - true - true - true - false - false - true - - - - - - - - - 59e0b89a-e487-49f8-bab8-b5bab16be14c - Panel - - - - + A panel for custom notes and text values 63a2f4e1-c253-4fc3-9148-719323b802e1 + true Panel false @@ -764,16 +703,17 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel - + A panel for custom notes and text values 5262b483-9441-440a-a74d-8b235aad399d + true Panel false @@ -816,17 +756,18 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews true 6f2c8a4b-d787-4606-9170-900f972641c6 + true Custom Preview Preview @@ -847,10 +788,11 @@ - + Geometry to preview true 43f69636-7c49-4472-9329-bd25ec713d12 + true Geometry G false @@ -875,9 +817,10 @@ - + The material override e22d7711-ceb9-48df-9270-b376fcd13ae6 + true Material M false @@ -935,17 +878,18 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews true 53c99f0b-499f-4471-9227-acc96558bfea + true Custom Preview Preview @@ -966,10 +910,11 @@ - + Geometry to preview true 525f46ad-33c4-44dc-8862-35b0ddce4d1d + true Geometry G false @@ -994,9 +939,10 @@ - + The material override 2e7559ef-c4d5-4ffe-a304-c34c078e5af0 + true Material M false @@ -1054,16 +1000,17 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch - + Colour (palette) swatch b14c32be-c541-4fae-93c2-449d7543457e + true Colour Swatch Swatch false @@ -1091,18 +1038,19 @@ - + a8b97322-2d53-47cd-905e-b932c3ccd74e Button - + Button object with two values False True 254a4a2f-d415-488e-9851-4a763f1ba58f + true Button dump! false @@ -1123,18 +1071,19 @@ - + 06953bda-1d37-4d58-9b38-4b3c74e54c8f File Path - + Contains a collection of file paths false All files|*.* 77c76654-6be3-4843-b564-afe44705740d + true File Path Path false @@ -1180,16 +1129,17 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel - + A panel for custom notes and text values 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 + true Panel false @@ -1232,16 +1182,17 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch - + Colour (palette) swatch fc5dba97-2c1a-4749-9c61-3f88abff00ff + true Colour Swatch Swatch false @@ -1269,17 +1220,18 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews true f2ae36bd-8b62-496c-ac97-17ab79c53f42 + true Custom Preview Preview @@ -1300,10 +1252,11 @@ - + Geometry to preview true 85ca540e-0ffd-46e5-b014-a0ddacc0562b + true Geometry G false @@ -1327,9 +1280,10 @@ - + The material override 6d95716c-757a-4c8f-8bb0-1685e7e04a52 + true Material M false @@ -1387,16 +1341,17 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch - + Colour (palette) swatch 83adf7c8-580d-4af6-a713-84bf5f8bd2d3 + true Colour Swatch Swatch false @@ -1424,18 +1379,17 @@ - + 919e146f-30ae-4aae-be34-4d72f555e7da Brep - + Contains a collection of Breps (Boundary REPresentations) true 39d914fb-05fc-4c33-93a8-98326df3e596 - true Brep Brep false @@ -1468,32 +1422,50 @@ - + + + 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 + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 - + + + 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 + 322f4e22-d195-435e-b290-052cb2318277 - + + + 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 + aa56315b-2905-4049-8c41-0cc8b39d864b - + + + 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 + 7fc04154-255a-413f-a8a1-6ea034e1e779 - + + + 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 + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 - + + + 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 + aeae5255-2a74-4040-9e44-e3aedf934485 @@ -1505,19 +1477,18 @@ - + 06953bda-1d37-4d58-9b38-4b3c74e54c8f File Path - + Contains a collection of file paths false All files|*.* 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 - true File Path Path false @@ -1563,19 +1534,18 @@ - + a8b97322-2d53-47cd-905e-b932c3ccd74e Button - + Button object with two values False True 66637ff1-037c-4e4c-ba3a-0930de00a3ea - true Button dump! false @@ -1596,17 +1566,16 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel - + A panel for custom notes and text values 66ce41af-42cf-48a0-871c-5d06b68b6ae7 - true Panel false @@ -1649,18 +1618,17 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews true 649b3c81-ba59-413f-ad42-15bca79f15e2 - true Custom Preview Preview @@ -1681,15 +1649,14 @@ - + Geometry to preview true 799c43bc-4b78-4d8f-a2ed-f604ed2b1ddb - true Geometry G false - 5769b0e3-b5fa-46e5-8b49-25088b83a917 + 86cd065e-41a3-4149-9a68-e3130b58ce76 1 @@ -1710,10 +1677,9 @@ - + The material override 07e88719-b77c-4ac3-a12c-cc329aefe255 - true Material M false @@ -1771,18 +1737,17 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews true 4d39988a-2c7d-4bb0-9261-f460ec916be1 - true Custom Preview Preview @@ -1803,15 +1768,14 @@ - + Geometry to preview true 8d9e002d-b2f2-4476-8f21-adea36efcb4a - true Geometry G false - 0cd168ad-f650-4b68-87a8-b45f32a6dbfc + c60f388a-008e-4a06-9770-68a2fa0520e7 1 @@ -1832,10 +1796,9 @@ - + The material override 58e8f37f-40e5-4060-83b0-c395fb2daf6d - true Material M false @@ -1893,17 +1856,16 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch - + Colour (palette) swatch c0aa2559-2d8c-481d-a41d-c02943a5f981 - true Colour Swatch Swatch false @@ -1931,17 +1893,16 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch - + Colour (palette) swatch 28b353a5-44f7-436e-8a36-957623e89dde - true Colour Swatch Swatch false @@ -1969,7 +1930,7 @@ - + c9b2d725-6f87-4b07-af90-bd9aefef68eb 066d0a87-236f-4eae-a0f4-9e42f5327962 @@ -1984,7 +1945,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= - 65e17a0f-52e4-4f2c-938f-4153c4d95177 + 0bc1d704-d9a5-496a-8097-0e77a2179817 true true false @@ -2001,14 +1962,14 @@ - 260 - 588 + 248 + 371 171 84 - 367 - 630 + 355 + 413 @@ -2030,16 +1991,16 @@ true Press button to export xml - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= - 9a169d71-5230-4a49-bd7a-e2f72347ebf0 + ff7bc6fc-cd70-4c56-8f79-fc4cbd06681c true i_dump i_dump true 0 true - 66637ff1-037c-4e4c-ba3a-0930de00a3ea + 508c9c16-1d49-4404-84cc-7cc48c8f273b 1 Press button to export xml d60527f5-b5af-4ef6-8970-5f96fe412559 @@ -2048,14 +2009,14 @@ - 262 - 590 + 250 + 373 90 20 - 308.5 - 600 + 296.5 + 383 @@ -2066,16 +2027,16 @@ true The name of the assembly to export. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC - e20c6b9b-9964-45e2-8b3a-f3526ce7d7a5 + eac6f337-07dc-4148-804b-ee5f29e1c0f7 true i_assembly_name i_assembly_name true 0 true - 66ce41af-42cf-48a0-871c-5d06b68b6ae7 + a170d6d1-471e-4c64-9806-444e47f21d66 1 The name of the assembly to export. 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -2084,14 +2045,14 @@ - 262 - 610 + 250 + 393 90 20 - 308.5 - 620 + 296.5 + 403 @@ -2102,16 +2063,16 @@ true The directors where to export the xml file. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC - 74ce08ea-85ea-42f1-9b6f-e415953f6a3d + 0341be27-157c-4fa0-8841-4876c4aa61b9 true i_export_dir i_export_dir true 0 true - 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 + 3f1b8093-20ad-4b03-90b2-110f234137fc 1 The directors where to export the xml file. 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -2120,14 +2081,14 @@ - 262 - 630 + 250 + 413 90 20 - 308.5 - 640 + 296.5 + 423 @@ -2139,16 +2100,16 @@ true The breps of the structure. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== - d700b88b-9d37-47c0-a242-80e85b5d4e00 + f7f134be-ff73-4607-8432-4027726d7c9a true i_breps i_breps true 1 true - 39d914fb-05fc-4c33-93a8-98326df3e596 + f6905f9e-831e-4c85-831f-4a85822df09c 1 The breps of the structure. 2ceb0405-fdfe-403d-a4d6-8786da45fb9d @@ -2157,14 +2118,14 @@ - 262 - 650 + 250 + 433 90 20 - 308.5 - 660 + 296.5 + 443 @@ -2175,9 +2136,9 @@ false The string of xml to be exported. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC - d4570a62-ba44-499e-a550-0cf9fa169720 + 63fce5d6-5cca-4c37-978e-16ad72dccdf6 true o_xml o_xml @@ -2192,14 +2153,14 @@ - 382 - 590 + 370 + 373 47 26 - 405.5 - 603.3333 + 393.5 + 386.33334 @@ -2209,11 +2170,1376 @@ false The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + d876ac7a-afbf-4696-a6c0-6b8d5230d058 + true + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 370 + 399 + 47 + 27 + + + 393.5 + 413 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + cd81b022-0563-4d70-8ad2-86542a5f5a10 + true + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 370 + 426 + 47 + 27 + + + 393.5 + 439.6667 + + + + + + + + + + false + IyEgcHl0aG9uMwojIHJlcXVpcmVtZW50czogZGlmZkNoZWNrCgppbXBvcnQgU3lzdGVtCmltcG9ydCB0eXBpbmcKCmltcG9ydCBSaGlubwppbXBvcnQgUmhpbm8uR2VvbWV0cnkgYXMgcmcKCmZyb20gZ2hweXRob25saWIuY29tcG9uZW50YmFzZSBpbXBvcnQgZXhlY3V0aW5nY29tcG9uZW50IGFzIGNvbXBvbmVudAoKaW1wb3J0IGRpZmZDaGVjawoKCmNsYXNzIERGWE1MRXhwb3J0ZXIoY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwKICAgICAgICAgICAgaV9kdW1wOiBib29sLAogICAgICAgICAgICBpX2Fzc2VtYmx5X25hbWUsCiAgICAgICAgICAgIGlfZXhwb3J0X2RpciwKICAgICAgICAgICAgaV9icmVwczogU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuSUxpc3RbUmhpbm8uR2VvbWV0cnkuQnJlcF0pOgogICAgICAgICIiIgogICAgICAgICAgICBUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zIDogdHlwaW5nLkxpc3RbZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMuREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcy5ERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sIDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICAgICAgaWYgaV9kdW1wOgogICAgICAgICAgICBhc3NlbWJseTEuZHVtcF94bWwoeG1sLCBpX2V4cG9ydF9kaXIpCiAgICAgICAgb194bWwgPSB4bWwKCiAgICAgICAgIyBzaG93IHRoZSBqb2ludC9zaWRlIGZhY2VzCiAgICAgICAgb19qb2ludHMgPSBbamYudG9fYnJlcCgpIGZvciBqZiBpbiBhc3NlbWJseTEuYWxsX2pvaW50X2ZhY2VzXQogICAgICAgIG9fc2lkZXMgPSBbc2YudG9fYnJlcCgpIGZvciBzZiBpbiBhc3NlbWJseTEuYWxsX3NpZGVfZmFjZXNdCgogICAgICAgIHJldHVybiBvX3htbCwgb19qb2ludHMsIG9fc2lkZXM= + S + + + + + *.*.python + 3.* + + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + f6905f9e-831e-4c85-831f-4a85822df09c + true + Brep + Brep + false + 0 + + + + + + 171 + 432 + 50 + 24 + + + 196.57437 + 444.25897 + + + + + + 1 + + + + + 6 + {0} + + + + + + 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 + + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 + + + + + + 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 + + aa56315b-2905-4049-8c41-0cc8b39d864b + + + + + + 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 + + 322f4e22-d195-435e-b290-052cb2318277 + + + + + + 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 + + 7fc04154-255a-413f-a8a1-6ea034e1e779 + + + + + + 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 + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + + 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 + + aeae5255-2a74-4040-9e44-e3aedf934485 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 508c9c16-1d49-4404-84cc-7cc48c8f273b + true + Button + dump! + false + 0 + + + + + + 118 + 372 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 3f1b8093-20ad-4b03-90b2-110f234137fc + true + File Path + Path + false + 0 + + + + + + 170 + 412 + 50 + 24 + + + 195.9993 + 424.0232 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + a170d6d1-471e-4c64-9806-444e47f21d66 + true + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 118 + 394 + 102 + 20 + + 0 + 0 + 0 + + 118.27825 + 394.3187 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + e82c0b60-8d4c-487a-8a2a-60ccdfb2c440 + true + Custom Preview + Preview + + + + + + + 544 + 371 + 48 + 44 + + + 578 + 393 + + + + + + Geometry to preview + true + f483e244-6e89-4839-a140-53b2307e5305 + true + Geometry + G + false + d876ac7a-afbf-4696-a6c0-6b8d5230d058 + 1 + + + + + + 546 + 373 + 17 + 20 + + + 556 + 383 + + + + + + + + The material override + 5eadcdca-b596-4817-b74a-daf84cb33bba + true + Material + M + false + 1652822d-91b6-4619-a0f1-929bd813d353 + 1 + + + + + + 546 + 393 + 17 + 20 + + + 556 + 403 + + + + + + 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 + 1cf1d421-79da-445c-baea-160043841df5 + true + Custom Preview + Preview + + + + + + + 545 + 418 + 48 + 44 + + + 579 + 440 + + + + + + Geometry to preview + true + f3c7f1be-a13f-418f-bdc3-968772d68045 + true + Geometry + G + false + cd81b022-0563-4d70-8ad2-86542a5f5a10 + 1 + + + + + + 547 + 420 + 17 + 20 + + + 557 + 430 + + + + + + + + The material override + 14b44143-7bb4-4e4b-a0c1-8aeb245e6588 + true + Material + M + false + c217b73e-3729-4db1-951f-b5914db0d7d8 + 1 + + + + + + 547 + 440 + 17 + 20 + + + 557 + 450 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 1652822d-91b6-4619-a0f1-929bd813d353 + true + Colour Swatch + Swatch + false + 0 + + 255;128;0;255 + + + + + + + 441 + 394 + 88 + 20 + + + 441.1697 + 394.63263 + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + c217b73e-3729-4db1-951f-b5914db0d7d8 + true + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 442 + 441 + 88 + 20 + + + 442.5322 + 441.6774 + + + + + + + + + + 719467e6-7cf5-4848-99b0-c5dd57e5442c + 066d0a87-236f-4eae-a0f4-9e42f5327962 + Python 3 Script + + + + + + true + true + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== + + 0ee66d25-d08b-438a-a320-7d5b9c94eb52 + true + true + true + true + Python 3 Script + Py3 + 1 + + false + false + true + + + + + + 741 + 549 + 72 + 44 + + + 770 + 571 + + + + + + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 2 + 3ede854e-c753-40eb-84cb-b48008f14fd4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 304ad97a-0eb9-4b5e-b99c-67c7dc5cf217 + true + x + x + true + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 743 + 551 + 12 + 20 + + + 750.5 + 561 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 4d5c2100-1520-4ea1-bb18-50d5e8b0298a + true + y + y + true + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 743 + 571 + 12 + 20 + + + 750.5 + 581 + + + + + + + + The execution information, as output and error streams + 968967a6-00d1-4d3d-b3ad-6c70cfd8eb1b + true + out + out + false + 0 + + + + + + 785 + 551 + 26 + 20 + + + 798 + 561 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + a527438a-a4ac-4f54-9476-6d7db1e76864 + true + a + a + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 785 + 571 + 26 + 20 + + + 798 + 581 + + + + + + + + + + aW1wb3J0IHN5cw0KDQpwcmludChzeXMuZXhlY3V0YWJsZSk= + Py3 + + + + + *.*.python + 3.* + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 27b8206c-38aa-46d8-a4b0-7b5ce810d60a + true + Panel + + false + 0 + 968967a6-00d1-4d3d-b3ad-6c70cfd8eb1b + 1 + Double click to edit panel content… + + + + + + 897 + 500 + 613 + 192 + + 0 + 0 + 0 + + 897.0558 + 500.78198 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + e074f5dc-5825-470f-9d04-403633051d0e + Panel + + false + 0 + 0 + Double click to edit panel content… + + + + + + 469 + 531 + 484 + 93 + + 0 + 0 + 0 + + 469.65152 + 531.01056 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 719467e6-7cf5-4848-99b0-c5dd57e5442c + 066d0a87-236f-4eae-a0f4-9e42f5327962 + Python 3 Script + + + + + + true + true + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== + + 82cff84c-8203-4d2d-a1d0-814c858ec33d + true + true + true + true + Python 3 Script + Py3 + 1 + + false + false + true + + + + + + 171 + 1 + 101 + 44 + + + 229 + 23 + + + + + + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 2 + 3ede854e-c753-40eb-84cb-b48008f14fd4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + 1 + true + Converts to collection of Breps (Boundary REPresentations) + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + 08532ae2-a7b8-4bcb-ba9f-c6a7a22fe36f + true + i_breps + i_breps + true + 1 + true + 0f309845-29e6-43ae-b255-cdb5c2d13da9 + 1 + + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 173 + 3 + 41 + 40 + + + 195 + 23 + + + + + + + + The execution information, as output and error streams + e73efe6e-ad59-49eb-837e-2c03904e0016 + true + out + out + false + 0 + + + + + + 244 + 3 + 26 + 20 + + + 257 + 13 + + + + + + + + false + rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - 5769b0e3-b5fa-46e5-8b49-25088b83a917 + f4b0de2e-fef0-4b9d-876f-55b17adececd true + a + a + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 244 + 23 + 26 + 20 + + + 257 + 33 + + + + + + + + + + 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 + Py3 + + + + + *.*.python + 3.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + This component reads breps, convert them to DFBeams and DFAssemblies and export it to XML. + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 4de40153-0a75-4628-b563-344d5ffd67b3 + true + false + true + DFXMLExporter + XMLout + 1 + + false + false + false + + + + + + 269 + 587 + 171 + 84 + + + 376 + 629 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + d2a467a2-6e5c-4d7d-ab29-b4f069e2f8fa + i_dump + i_dump + true + 0 + true + 66637ff1-037c-4e4c-ba3a-0930de00a3ea + 1 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 271 + 589 + 90 + 20 + + + 317.5 + 599 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + 1a5dae8c-fb00-417f-93e7-28d577f4f02e + i_assembly_name + i_assembly_name + true + 0 + true + 66ce41af-42cf-48a0-871c-5d06b68b6ae7 + 1 + The name of the assembly to export. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 271 + 609 + 90 + 20 + + + 317.5 + 619 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + 00cdf837-c7db-48a9-83e1-57e3739e8261 + i_export_dir + i_export_dir + true + 0 + true + 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 + 1 + The directors where to export the xml file. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 271 + 629 + 90 + 20 + + + 317.5 + 639 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + d4f34513-7e3b-44d3-a110-13f6f2645a98 + i_breps + i_breps + true + 1 + true + 39d914fb-05fc-4c33-93a8-98326df3e596 + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 271 + 649 + 90 + 20 + + + 317.5 + 659 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 660dadfd-116c-4c27-a8a3-cecab444fb7a + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 391 + 589 + 47 + 26 + + + 414.5 + 602.3333 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 86cd065e-41a3-4149-9a68-e3130b58ce76 o_joints o_joints false @@ -2227,28 +3553,27 @@ - 382 - 616 + 391 + 615 47 27 - 405.5 - 630 + 414.5 + 629 - + false The breps of the faces belonging to sides. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== - 0cd168ad-f650-4b68-87a8-b45f32a6dbfc - true + c60f388a-008e-4a06-9770-68a2fa0520e7 o_sides o_sides false @@ -2262,14 +3587,14 @@ - 382 - 643 + 391 + 642 47 27 - 405.5 - 656.6666 + 414.5 + 655.6666 @@ -2280,7 +3605,7 @@ false - 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 + IyEgcHl0aG9uMwojIHI6IGRpZmZDaGVjaz09MC4wLjgKCmltcG9ydCBTeXN0ZW0KaW1wb3J0IHR5cGluZwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKZnJvbSBnaHB5dGhvbmxpYi5jb21wb25lbnRiYXNlIGltcG9ydCBleGVjdXRpbmdjb21wb25lbnQgYXMgY29tcG9uZW50CgppbXBvcnQgZGlmZkNoZWNrCmZyb20gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMgaW1wb3J0IERGQmVhbSwgREZBc3NlbWJseQoKCmNsYXNzIERGWE1MRXhwb3J0ZXIoY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwKICAgICAgICAgICAgaV9kdW1wOiBib29sLAogICAgICAgICAgICBpX2Fzc2VtYmx5X25hbWU6IHN0ciwKICAgICAgICAgICAgaV9leHBvcnRfZGlyOiBzdHIsCiAgICAgICAgICAgIGlfYnJlcHM6IFN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLklMaXN0W1JoaW5vLkdlb21ldHJ5LkJyZXBdKToKICAgICAgICAiIiIKICAgICAgICAgICAgVGhpcyByZWFkIGJyZXBzIGZyb20gUmhpbm8sIGNvbnZlcnRzIHRoZW0gdG8gREZCZWFtcyBhbmQgREZBc3NlbWJsaWVzLCBhbmQgZXhwb3J0cyB0aGVtIHRvIFhNTC4KICAgICAgICAgICAgCiAgICAgICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgICIiIgogICAgICAgICMgYmVhbXMKICAgICAgICBiZWFtczogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sOiBzdHIgPSBhc3NlbWJseTEudG9feG1sKCkKICAgICAgICBpZiBpX2R1bXA6CiAgICAgICAgICAgIGFzc2VtYmx5MS5kdW1wX3htbCh4bWwsIGlfZXhwb3J0X2RpcikKICAgICAgICBvX3htbCA9IHhtbAoKICAgICAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgICAgICBvX2pvaW50cyA9IFtqZi50b19icmVwKCkgZm9yIGpmIGluIGFzc2VtYmx5MS5hbGxfam9pbnRfZmFjZXNdCiAgICAgICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10KCiAgICAgICAgcmV0dXJuIG9feG1sLCBvX2pvaW50cywgb19zaWRlcw== S @@ -2303,7 +3628,7 @@ - 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 + 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 From 9a80177c7ebbde19f399239e402cd25f9f6f9858 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 15 Apr 2024 13:06:42 +0200 Subject: [PATCH 044/141] FIX: added numpy to module --- src/gh/components/DF_xml_exporter/code.py | 1 + src/gh/diffCheck/diffCheck/df_geometries.py | 1 + .../diffCheck/diffCheck/df_transformations.py | 6 +- src/gh/diffCheck/diffCheck/diffCheck_app.py | 15 +- src/gh/tester.ghx | 398 +++++++++--------- 5 files changed, 218 insertions(+), 203 deletions(-) diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py index 38ba2b10..5b3a19d2 100644 --- a/src/gh/components/DF_xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -1,5 +1,6 @@ #! python3 # r: diffCheck==0.0.8 +# r: numpy import System import typing diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 47dbff55..2e78848d 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -195,6 +195,7 @@ def from_brep(cls, brep): for data in data_faces: face = DFFace.from_brep(data[0], data[1]) faces.append(face) + print("TEEEEEEEEST") beam = cls("Beam", faces) return beam diff --git a/src/gh/diffCheck/diffCheck/df_transformations.py b/src/gh/diffCheck/diffCheck/df_transformations.py index c72adb1c..0879c79a 100644 --- a/src/gh/diffCheck/diffCheck/df_transformations.py +++ b/src/gh/diffCheck/diffCheck/df_transformations.py @@ -85,7 +85,6 @@ def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: return plane_src = biggest_face.TryGetPlane()[1] plane_tgt = Rhino.Geometry.Plane.WorldXY - print("Found plane for longest edge: " + str(plane_src)) # plane to plane transformation x_form_pln2pln = Rhino.Geometry.Transform.PlaneToPlane(plane_src, plane_tgt) @@ -109,9 +108,10 @@ def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: x_form_transl_B = None x_form_rot90z = None if x_val_sum > y_val_sum: - print("Bounding box is alligned to x axis. No rotation needed.") + # AABB is alligned to x axis. No rotation needed + pass else: - print("Bounding box is not alligned to y axis. A 90 deg rotation is needed.") + # AABB is not alligned to y axis. A 90 deg rotation is needed. x_form_rot90z = Rhino.Geometry.Transform.Rotation( math.radians(90), rg.Vector3d.ZAxis, rg.Point3d.Origin ) diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index fd5a9264..5cadb013 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -7,10 +7,14 @@ import typing import diffCheck -import diffCheck.df_util -from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly +import diffCheck.df_geometries -import diffCheck.df_joint_detector + +import sys +import importlib +for key in list(sys.modules.keys()): + if "diffCheck" in key: + importlib.reload(sys.modules[key]) if __name__ == "__main__": """ @@ -22,12 +26,11 @@ # beams beams = [] for brep in i_breps: - beam = DFBeam.from_brep(brep) - print(beam) + beam = diffCheck.df_geometries.DFBeam.from_brep(brep) beams.append(beam) # assembly - assembly1 = DFAssembly(beams, i_assembly_name) + assembly1 = diffCheck.df_geometries.DFAssembly(beams, i_assembly_name) # dump the xml xml: str = assembly1.to_xml() diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index d3676569..27e2cad4 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 163 - -418 + 95 + 154 - 0.92118883 + 1.0837504 @@ -111,7 +111,7 @@ - + true 2 @@ -119,7 +119,6 @@ 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 dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 - true true false true @@ -162,14 +161,13 @@ - + true Connect a button to open a file dialog to select a cpython file to run. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= 083c2fe3-a45a-43c1-8f85-ce20a4a69a99 - true btn btn true @@ -198,14 +196,13 @@ - + true rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== e0ef2066-70a4-441f-906b-8a4afddb0692 - true i_export_dir i_export_dir true @@ -234,7 +231,7 @@ - + 1 true Converts to collection of Breps (Boundary REPresentations) @@ -242,7 +239,6 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= ae8c9c0d-8d6a-4a8c-812a-110846a2031c - true i_breps i_breps true @@ -271,14 +267,13 @@ - + true rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== d9632669-508e-4a03-b9bc-a5d740ef546f - true i_assembly_name i_assembly_name true @@ -307,14 +302,13 @@ - + true Converts to collection of boolean values iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC 1e3c2c63-ede9-4faf-9790-a3d1b9350ba3 - true i_dump i_dump true @@ -343,14 +337,13 @@ - + false The redirected standard output of the component scriptsync. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 - true stdout stdout false @@ -378,14 +371,13 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== a849584f-8d8a-4547-a1a4-36be0bf3ac37 - true o_xml o_xml false @@ -413,14 +405,13 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 178951a0-3c74-4810-aef0-87cc45b0502c - true o_joints o_joints false @@ -448,14 +439,13 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 76758d37-2a1d-412d-b85b-149ecda8a020 - true o_sides o_sides false @@ -510,12 +500,11 @@ - + Button object with two values False True 5f8bfbf4-70d5-46ba-90fa-f3804e9a9032 - true Button false @@ -543,11 +532,10 @@ - + Contains a collection of Breps (Boundary REPresentations) true 0f309845-29e6-43ae-b255-cdb5c2d13da9 - true Brep Brep false @@ -580,10 +568,7 @@ - - - 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 - + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 @@ -602,10 +587,9 @@ - + A panel for custom notes and text values 6ffd83cc-a073-46cd-8213-4c0663708aa7 - true Panel false @@ -618,8 +602,8 @@ - 445 - -189 + 418 + -193 494 251 @@ -627,8 +611,8 @@ 0 0 - 445.17487 - -188.04263 + 418.41595 + -192.65623 @@ -663,8 +647,8 @@ Panel false - 0 - 178951a0-3c74-4810-aef0-87cc45b0502c + 1 + 3b1f5a65-4f18-4dc9-ad6f-bd8872256cbe 1 Double click to edit panel content… @@ -674,14 +658,14 @@ 627 289 - 411 + 748 166 0 0 0 - 627.30396 + 627.5534 289.70813 @@ -710,10 +694,9 @@ - + A panel for custom notes and text values 5262b483-9441-440a-a74d-8b235aad399d - true Panel false @@ -763,11 +746,10 @@ - + Allows for customized geometry previews true 6f2c8a4b-d787-4606-9170-900f972641c6 - true Custom Preview Preview @@ -788,11 +770,10 @@ - + Geometry to preview true 43f69636-7c49-4472-9329-bd25ec713d12 - true Geometry G false @@ -817,10 +798,9 @@ - + The material override e22d7711-ceb9-48df-9270-b376fcd13ae6 - true Material M false @@ -885,11 +865,10 @@ - + Allows for customized geometry previews true 53c99f0b-499f-4471-9227-acc96558bfea - true Custom Preview Preview @@ -910,11 +889,10 @@ - + Geometry to preview true 525f46ad-33c4-44dc-8862-35b0ddce4d1d - true Geometry G false @@ -939,10 +917,9 @@ - + The material override 2e7559ef-c4d5-4ffe-a304-c34c078e5af0 - true Material M false @@ -1007,10 +984,9 @@ - + Colour (palette) swatch b14c32be-c541-4fae-93c2-449d7543457e - true Colour Swatch Swatch false @@ -1045,12 +1021,11 @@ - + Button object with two values False True 254a4a2f-d415-488e-9851-4a763f1ba58f - true Button dump! false @@ -1078,12 +1053,11 @@ - + Contains a collection of file paths false All files|*.* 77c76654-6be3-4843-b564-afe44705740d - true File Path Path false @@ -1136,10 +1110,9 @@ - + A panel for custom notes and text values 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 - true Panel false @@ -1189,10 +1162,9 @@ - + Colour (palette) swatch fc5dba97-2c1a-4749-9c61-3f88abff00ff - true Colour Swatch Swatch false @@ -1227,11 +1199,10 @@ - + Allows for customized geometry previews true f2ae36bd-8b62-496c-ac97-17ab79c53f42 - true Custom Preview Preview @@ -1252,11 +1223,10 @@ - + Geometry to preview true 85ca540e-0ffd-46e5-b014-a0ddacc0562b - true Geometry G false @@ -1280,10 +1250,9 @@ - + The material override 6d95716c-757a-4c8f-8bb0-1685e7e04a52 - true Material M false @@ -1348,10 +1317,9 @@ - + Colour (palette) swatch 83adf7c8-580d-4af6-a713-84bf5f8bd2d3 - true Colour Swatch Swatch false @@ -1386,10 +1354,11 @@ - + Contains a collection of Breps (Boundary REPresentations) true 39d914fb-05fc-4c33-93a8-98326df3e596 + true Brep Brep false @@ -1422,50 +1391,32 @@ - - - 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 - + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 - - - 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 - + 322f4e22-d195-435e-b290-052cb2318277 - - - 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 - + aa56315b-2905-4049-8c41-0cc8b39d864b - - - 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 - + 7fc04154-255a-413f-a8a1-6ea034e1e779 - - - 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 - + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 - - - 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 - + aeae5255-2a74-4040-9e44-e3aedf934485 @@ -1484,11 +1435,12 @@ - + Contains a collection of file paths false All files|*.* 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 + true File Path Path false @@ -1541,11 +1493,12 @@ - + Button object with two values False True 66637ff1-037c-4e4c-ba3a-0930de00a3ea + true Button dump! false @@ -1573,9 +1526,10 @@ - + A panel for custom notes and text values 66ce41af-42cf-48a0-871c-5d06b68b6ae7 + true Panel false @@ -1625,10 +1579,11 @@ - + Allows for customized geometry previews true 649b3c81-ba59-413f-ad42-15bca79f15e2 + true Custom Preview Preview @@ -1649,10 +1604,11 @@ - + Geometry to preview true 799c43bc-4b78-4d8f-a2ed-f604ed2b1ddb + true Geometry G false @@ -1677,9 +1633,10 @@ - + The material override 07e88719-b77c-4ac3-a12c-cc329aefe255 + true Material M false @@ -1744,10 +1701,11 @@ - + Allows for customized geometry previews true 4d39988a-2c7d-4bb0-9261-f460ec916be1 + true Custom Preview Preview @@ -1768,10 +1726,11 @@ - + Geometry to preview true 8d9e002d-b2f2-4476-8f21-adea36efcb4a + true Geometry G false @@ -1796,9 +1755,10 @@ - + The material override 58e8f37f-40e5-4060-83b0-c395fb2daf6d + true Material M false @@ -1863,9 +1823,10 @@ - + Colour (palette) swatch c0aa2559-2d8c-481d-a41d-c02943a5f981 + true Colour Swatch Swatch false @@ -1900,9 +1861,10 @@ - + Colour (palette) swatch 28b353a5-44f7-436e-8a36-957623e89dde + true Colour Swatch Swatch false @@ -1956,7 +1918,7 @@ false false - false + true @@ -1974,18 +1936,19 @@ - + 4 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa - 3 - 08908df5-fa14-4982-9ab2-1aa0927566aa + 4 + 3ede854e-c753-40eb-84cb-b48008f14fd4 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa - + true @@ -2132,6 +2095,33 @@ + + The execution information, as output and error streams + 3b1f5a65-4f18-4dc9-ad6f-bd8872256cbe + true + out + out + false + 0 + + + + + + 370 + 373 + 47 + 20 + + + 393.5 + 383 + + + + + + false The string of xml to be exported. @@ -2154,19 +2144,19 @@ 370 - 373 + 393 47 - 26 + 20 393.5 - 386.33334 + 403 - + false The breps of the faces belonging to joints. @@ -2189,19 +2179,19 @@ 370 - 399 + 413 47 - 27 + 20 393.5 - 413 + 423 - + false The breps of the faces belonging to sides. @@ -2224,13 +2214,13 @@ 370 - 426 + 433 47 - 27 + 20 393.5 - 439.6667 + 443 @@ -2241,7 +2231,7 @@ false - IyEgcHl0aG9uMwojIHJlcXVpcmVtZW50czogZGlmZkNoZWNrCgppbXBvcnQgU3lzdGVtCmltcG9ydCB0eXBpbmcKCmltcG9ydCBSaGlubwppbXBvcnQgUmhpbm8uR2VvbWV0cnkgYXMgcmcKCmZyb20gZ2hweXRob25saWIuY29tcG9uZW50YmFzZSBpbXBvcnQgZXhlY3V0aW5nY29tcG9uZW50IGFzIGNvbXBvbmVudAoKaW1wb3J0IGRpZmZDaGVjawoKCmNsYXNzIERGWE1MRXhwb3J0ZXIoY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwKICAgICAgICAgICAgaV9kdW1wOiBib29sLAogICAgICAgICAgICBpX2Fzc2VtYmx5X25hbWUsCiAgICAgICAgICAgIGlfZXhwb3J0X2RpciwKICAgICAgICAgICAgaV9icmVwczogU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuSUxpc3RbUmhpbm8uR2VvbWV0cnkuQnJlcF0pOgogICAgICAgICIiIgogICAgICAgICAgICBUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zIDogdHlwaW5nLkxpc3RbZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMuREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcy5ERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sIDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICAgICAgaWYgaV9kdW1wOgogICAgICAgICAgICBhc3NlbWJseTEuZHVtcF94bWwoeG1sLCBpX2V4cG9ydF9kaXIpCiAgICAgICAgb194bWwgPSB4bWwKCiAgICAgICAgIyBzaG93IHRoZSBqb2ludC9zaWRlIGZhY2VzCiAgICAgICAgb19qb2ludHMgPSBbamYudG9fYnJlcCgpIGZvciBqZiBpbiBhc3NlbWJseTEuYWxsX2pvaW50X2ZhY2VzXQogICAgICAgIG9fc2lkZXMgPSBbc2YudG9fYnJlcCgpIGZvciBzZiBpbiBhc3NlbWJseTEuYWxsX3NpZGVfZmFjZXNdCgogICAgICAgIHJldHVybiBvX3htbCwgb19qb2ludHMsIG9fc2lkZXM= + IyEgcHl0aG9uMwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKaW1wb3J0IG9zCmltcG9ydCB0eXBpbmcKCmltcG9ydCBkaWZmQ2hlY2sKCgoKaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKICAgICIiIgogICAgICAgIE1haW4gZnVuY3Rpb24gdG8gdGVzdCB0aGUgcGFja2FnZQogICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICIiIgogICAgIyBiZWFtcwogICAgYmVhbXMgPSBbXQogICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICBiZWFtID0gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMuREZCZWFtLmZyb21fYnJlcChicmVwKQogICAgICAgIGJlYW1zLmFwcGVuZChiZWFtKQoKICAgICMgYXNzZW1ibHkKICAgIGFzc2VtYmx5MSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQXNzZW1ibHkoYmVhbXMsIGlfYXNzZW1ibHlfbmFtZSkKCiAgICAjIGR1bXAgdGhlIHhtbAogICAgeG1sOiBzdHIgPSBhc3NlbWJseTEudG9feG1sKCkKICAgIGlmIGlfZHVtcDoKICAgICAgICBhc3NlbWJseTEuZHVtcF94bWwoeG1sLCBpX2V4cG9ydF9kaXIpCiAgICBvX3htbCA9IHhtbAoKICAgICMgc2hvdyB0aGUgam9pbnQvc2lkZSBmYWNlcwogICAgb19qb2ludHMgPSBbamYudG9fYnJlcCgpIGZvciBqZiBpbiBhc3NlbWJseTEuYWxsX2pvaW50X2ZhY2VzXQogICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10K S @@ -2301,50 +2291,32 @@ - - - 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 - + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 - - - 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 - + aa56315b-2905-4049-8c41-0cc8b39d864b - - - 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 - + 322f4e22-d195-435e-b290-052cb2318277 - - - 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 - + 7fc04154-255a-413f-a8a1-6ea034e1e779 - - - 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 - + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 - - - 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 - + aeae5255-2a74-4040-9e44-e3aedf934485 @@ -3086,31 +3058,33 @@ - + A panel for custom notes and text values e074f5dc-5825-470f-9d04-403633051d0e + true Panel false - 0 - 0 + 1 + 109ec47e-a6f8-4875-8368-b724abf2abe2 + 1 Double click to edit panel content… - 469 - 531 + 513 + 553 484 - 93 + 186 0 0 0 - 469.65152 - 531.01056 + 513.0737 + 553.69006 @@ -3310,14 +3284,15 @@ - - This component reads breps, convert them to DFBeams and DFAssemblies and export it to XML. + + true 2 iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= 4de40153-0a75-4628-b563-344d5ffd67b3 + true true false true @@ -3327,7 +3302,7 @@ false false - false + true @@ -3345,26 +3320,28 @@ - + 4 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa - 3 - 08908df5-fa14-4982-9ab2-1aa0927566aa + 4 + 3ede854e-c753-40eb-84cb-b48008f14fd4 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa - + - + true Press button to export xml - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= d2a467a2-6e5c-4d7d-ab29-b4f069e2f8fa + true i_dump i_dump true @@ -3393,13 +3370,14 @@ - + true The name of the assembly to export. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 1a5dae8c-fb00-417f-93e7-28d577f4f02e + true i_assembly_name i_assembly_name true @@ -3408,7 +3386,7 @@ 66ce41af-42cf-48a0-871c-5d06b68b6ae7 1 The name of the assembly to export. - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -3428,13 +3406,14 @@ - + true The directors where to export the xml file. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 00cdf837-c7db-48a9-83e1-57e3739e8261 + true i_export_dir i_export_dir true @@ -3443,7 +3422,7 @@ 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 1 The directors where to export the xml file. - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -3463,14 +3442,15 @@ - + 1 true The breps of the structure. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== d4f34513-7e3b-44d3-a110-13f6f2645a98 + true i_breps i_breps true @@ -3499,13 +3479,41 @@ - + + The execution information, as output and error streams + 109ec47e-a6f8-4875-8368-b724abf2abe2 + true + out + out + false + 0 + + + + + + 391 + 589 + 47 + 20 + + + 414.5 + 599 + + + + + + + false The string of xml to be exported. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 660dadfd-116c-4c27-a8a3-cecab444fb7a + true o_xml o_xml false @@ -3520,26 +3528,27 @@ 391 - 589 + 609 47 - 26 + 20 414.5 - 602.3333 + 619 - - + + false The breps of the faces belonging to joints. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 86cd065e-41a3-4149-9a68-e3130b58ce76 + true o_joints o_joints false @@ -3554,26 +3563,27 @@ 391 - 615 + 629 47 - 27 + 20 414.5 - 629 + 639 - - + + false The breps of the faces belonging to sides. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC c60f388a-008e-4a06-9770-68a2fa0520e7 + true o_sides o_sides false @@ -3588,13 +3598,13 @@ 391 - 642 + 649 47 - 27 + 20 414.5 - 655.6666 + 659 @@ -3605,7 +3615,7 @@ false - IyEgcHl0aG9uMwojIHI6IGRpZmZDaGVjaz09MC4wLjgKCmltcG9ydCBTeXN0ZW0KaW1wb3J0IHR5cGluZwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKZnJvbSBnaHB5dGhvbmxpYi5jb21wb25lbnRiYXNlIGltcG9ydCBleGVjdXRpbmdjb21wb25lbnQgYXMgY29tcG9uZW50CgppbXBvcnQgZGlmZkNoZWNrCmZyb20gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMgaW1wb3J0IERGQmVhbSwgREZBc3NlbWJseQoKCmNsYXNzIERGWE1MRXhwb3J0ZXIoY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwKICAgICAgICAgICAgaV9kdW1wOiBib29sLAogICAgICAgICAgICBpX2Fzc2VtYmx5X25hbWU6IHN0ciwKICAgICAgICAgICAgaV9leHBvcnRfZGlyOiBzdHIsCiAgICAgICAgICAgIGlfYnJlcHM6IFN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLklMaXN0W1JoaW5vLkdlb21ldHJ5LkJyZXBdKToKICAgICAgICAiIiIKICAgICAgICAgICAgVGhpcyByZWFkIGJyZXBzIGZyb20gUmhpbm8sIGNvbnZlcnRzIHRoZW0gdG8gREZCZWFtcyBhbmQgREZBc3NlbWJsaWVzLCBhbmQgZXhwb3J0cyB0aGVtIHRvIFhNTC4KICAgICAgICAgICAgCiAgICAgICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgICIiIgogICAgICAgICMgYmVhbXMKICAgICAgICBiZWFtczogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sOiBzdHIgPSBhc3NlbWJseTEudG9feG1sKCkKICAgICAgICBpZiBpX2R1bXA6CiAgICAgICAgICAgIGFzc2VtYmx5MS5kdW1wX3htbCh4bWwsIGlfZXhwb3J0X2RpcikKICAgICAgICBvX3htbCA9IHhtbAoKICAgICAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgICAgICBvX2pvaW50cyA9IFtqZi50b19icmVwKCkgZm9yIGpmIGluIGFzc2VtYmx5MS5hbGxfam9pbnRfZmFjZXNdCiAgICAgICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10KCiAgICAgICAgcmV0dXJuIG9feG1sLCBvX2pvaW50cywgb19zaWRlcw== + IyEgcHl0aG9uMwoKCmltcG9ydCBTeXN0ZW0KaW1wb3J0IHR5cGluZwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKZnJvbSBnaHB5dGhvbmxpYi5jb21wb25lbnRiYXNlIGltcG9ydCBleGVjdXRpbmdjb21wb25lbnQgYXMgY29tcG9uZW50CgppbXBvcnQgZGlmZkNoZWNrCmZyb20gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMgaW1wb3J0IERGQmVhbSwgREZBc3NlbWJseQoKCmNsYXNzIERGWE1MRXhwb3J0ZXIoY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwKICAgICAgICAgICAgaV9kdW1wOiBib29sLAogICAgICAgICAgICBpX2Fzc2VtYmx5X25hbWUsCiAgICAgICAgICAgIGlfZXhwb3J0X2RpciwKICAgICAgICAgICAgaV9icmVwczogU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuSUxpc3RbUmhpbm8uR2VvbWV0cnkuQnJlcF0pOgogICAgICAgICIiIgogICAgICAgICAgICBUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zOiB0eXBpbmcuTGlzdFtERkJlYW1dID0gW10KICAgICAgICBmb3IgYnJlcCBpbiBpX2JyZXBzOgogICAgICAgICAgICBiZWFtID0gREZCZWFtLmZyb21fYnJlcChicmVwKQogICAgICAgICAgICBiZWFtcy5hcHBlbmQoYmVhbSkKCiAgICAgICAgIyBhc3NlbWJseQogICAgICAgIGFzc2VtYmx5MSA9IERGQXNzZW1ibHkoYmVhbXMsIGlfYXNzZW1ibHlfbmFtZSkKCiAgICAgICAgIyBkdW1wIHRoZSB4bWwKICAgICAgICB4bWw6IHN0ciA9IGFzc2VtYmx5MS50b194bWwoKQogICAgICAgIGlmIGlfZHVtcDoKICAgICAgICAgICAgYXNzZW1ibHkxLmR1bXBfeG1sKHhtbCwgaV9leHBvcnRfZGlyKQogICAgICAgIG9feG1sID0geG1sCgogICAgICAgICMgc2hvdyB0aGUgam9pbnQvc2lkZSBmYWNlcwogICAgICAgIG9fam9pbnRzID0gW2pmLnRvX2JyZXAoKSBmb3IgamYgaW4gYXNzZW1ibHkxLmFsbF9qb2ludF9mYWNlc10KICAgICAgICBvX3NpZGVzID0gW3NmLnRvX2JyZXAoKSBmb3Igc2YgaW4gYXNzZW1ibHkxLmFsbF9zaWRlX2ZhY2VzXQoKICAgICAgICByZXR1cm4gb194bWwsIG9fam9pbnRzLCBvX3NpZGVz S @@ -3628,7 +3638,7 @@ - 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 + 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 From a2c1246746b7e4288e1292b7b96f3ede5b06becf Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 15 Apr 2024 13:16:43 +0200 Subject: [PATCH 045/141] FIX: no need for numpy for diffcheck --- src/gh/components/DF_xml_exporter/code.py | 1 - src/gh/diffCheck/diffCheck/df_geometries.py | 1 - 2 files changed, 2 deletions(-) diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py index 5b3a19d2..38ba2b10 100644 --- a/src/gh/components/DF_xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -1,6 +1,5 @@ #! python3 # r: diffCheck==0.0.8 -# r: numpy import System import typing diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py index 2e78848d..47dbff55 100644 --- a/src/gh/diffCheck/diffCheck/df_geometries.py +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -195,7 +195,6 @@ def from_brep(cls, brep): for data in data_faces: face = DFFace.from_brep(data[0], data[1]) faces.append(face) - print("TEEEEEEEEST") beam = cls("Beam", faces) return beam From 0bf7ecd1f43fe0f2287393a57e958bd876ec55a2 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 15 Apr 2024 13:47:29 +0200 Subject: [PATCH 046/141] FIX: missing math import --- src/gh/components/DF_xml_exporter/code.py | 2 +- src/gh/diffCheck/diffCheck/__init__.py | 2 +- .../diffCheck/diffCheck/df_transformations.py | 1 + src/gh/diffCheck/diffCheck/diffCheck_app.py | 1 - src/gh/diffCheck/diffCheck/newmodule.py | 5 +++ src/gh/diffCheck/setup.py | 2 +- src/gh/tester.ghx | 36 +++++++++---------- 7 files changed, 25 insertions(+), 24 deletions(-) create mode 100644 src/gh/diffCheck/diffCheck/newmodule.py diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py index 38ba2b10..e3ae43b8 100644 --- a/src/gh/components/DF_xml_exporter/code.py +++ b/src/gh/components/DF_xml_exporter/code.py @@ -1,5 +1,5 @@ #! python3 -# r: diffCheck==0.0.8 +# r: diffCheck==0.0.9 import System import typing diff --git a/src/gh/diffCheck/diffCheck/__init__.py b/src/gh/diffCheck/diffCheck/__init__.py index 71eb32d8..2418e6b6 100644 --- a/src/gh/diffCheck/diffCheck/__init__.py +++ b/src/gh/diffCheck/diffCheck/__init__.py @@ -1 +1 @@ -__version__ = "0.0.8" \ No newline at end of file +__version__ = "0.0.9" \ 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 0879c79a..20d529b8 100644 --- a/src/gh/diffCheck/diffCheck/df_transformations.py +++ b/src/gh/diffCheck/diffCheck/df_transformations.py @@ -3,6 +3,7 @@ import scriptcontext as sc import numpy as np +import math def get_inverse_transformation( diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck/diffCheck_app.py index 5cadb013..51d218ee 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck/diffCheck_app.py @@ -9,7 +9,6 @@ import diffCheck import diffCheck.df_geometries - import sys import importlib for key in list(sys.modules.keys()): diff --git a/src/gh/diffCheck/diffCheck/newmodule.py b/src/gh/diffCheck/diffCheck/newmodule.py new file mode 100644 index 00000000..452195e1 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/newmodule.py @@ -0,0 +1,5 @@ + + + +def test_new_mdoule(): + print("hello from test_new_mdoule") \ No newline at end of file diff --git a/src/gh/diffCheck/setup.py b/src/gh/diffCheck/setup.py index 331e6e6a..921b98c4 100644 --- a/src/gh/diffCheck/setup.py +++ b/src/gh/diffCheck/setup.py @@ -2,7 +2,7 @@ setup( name="diffCheck", - version="0.0.8", + version="0.0.9", packages=find_packages(), install_requires=[ "numpy", diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index 27e2cad4..5d0e9d93 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 95 - 154 + 221 + 94 - 1.0837504 + 0.72582066 @@ -657,16 +657,16 @@ 627 - 289 + 305 748 - 166 + 153 0 0 0 627.5534 - 289.70813 + 305.93573 @@ -2231,7 +2231,7 @@ false - IyEgcHl0aG9uMwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKaW1wb3J0IG9zCmltcG9ydCB0eXBpbmcKCmltcG9ydCBkaWZmQ2hlY2sKCgoKaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKICAgICIiIgogICAgICAgIE1haW4gZnVuY3Rpb24gdG8gdGVzdCB0aGUgcGFja2FnZQogICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICIiIgogICAgIyBiZWFtcwogICAgYmVhbXMgPSBbXQogICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICBiZWFtID0gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMuREZCZWFtLmZyb21fYnJlcChicmVwKQogICAgICAgIGJlYW1zLmFwcGVuZChiZWFtKQoKICAgICMgYXNzZW1ibHkKICAgIGFzc2VtYmx5MSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQXNzZW1ibHkoYmVhbXMsIGlfYXNzZW1ibHlfbmFtZSkKCiAgICAjIGR1bXAgdGhlIHhtbAogICAgeG1sOiBzdHIgPSBhc3NlbWJseTEudG9feG1sKCkKICAgIGlmIGlfZHVtcDoKICAgICAgICBhc3NlbWJseTEuZHVtcF94bWwoeG1sLCBpX2V4cG9ydF9kaXIpCiAgICBvX3htbCA9IHhtbAoKICAgICMgc2hvdyB0aGUgam9pbnQvc2lkZSBmYWNlcwogICAgb19qb2ludHMgPSBbamYudG9fYnJlcCgpIGZvciBqZiBpbiBhc3NlbWJseTEuYWxsX2pvaW50X2ZhY2VzXQogICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10K + IyEgcHl0aG9uMwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKaW1wb3J0IG9zCmltcG9ydCB0eXBpbmcKCmltcG9ydCBkaWZmQ2hlY2sKCmltcG9ydCBkaWZmQ2hlY2submV3bW9kdWxlCmRpZmZDaGVjay5uZXdtb2R1bGUudGVzdF9uZXdfbWRvdWxlKCkKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICAiIiIKICAgICAgICBNYWluIGZ1bmN0aW9uIHRvIHRlc3QgdGhlIHBhY2thZ2UKICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAiIiIKICAgICMgYmVhbXMKICAgIGJlYW1zID0gW10KICAgIGZvciBicmVwIGluIGlfYnJlcHM6CiAgICAgICAgYmVhbSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICBiZWFtcy5hcHBlbmQoYmVhbSkKCiAgICAjIGFzc2VtYmx5CiAgICBhc3NlbWJseTEgPSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcy5ERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgIyBkdW1wIHRoZSB4bWwKICAgIHhtbDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICBpZiBpX2R1bXA6CiAgICAgICAgYXNzZW1ibHkxLmR1bXBfeG1sKHhtbCwgaV9leHBvcnRfZGlyKQogICAgb194bWwgPSB4bWwKCiAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgIG9fam9pbnRzID0gW2pmLnRvX2JyZXAoKSBmb3IgamYgaW4gYXNzZW1ibHkxLmFsbF9qb2ludF9mYWNlc10KICAgIG9fc2lkZXMgPSBbc2YudG9fYnJlcCgpIGZvciBzZiBpbiBhc3NlbWJseTEuYWxsX3NpZGVfZmFjZXNdCg== S @@ -3075,16 +3075,16 @@ 513 - 553 + 511 484 - 186 + 241 0 0 0 513.0737 - 553.69006 + 511.42526 @@ -3113,7 +3113,7 @@ - + true true @@ -3121,7 +3121,6 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== 82cff84c-8203-4d2d-a1d0-814c858ec33d - true true true true @@ -3158,7 +3157,7 @@ - + 1 true Converts to collection of Breps (Boundary REPresentations) @@ -3166,7 +3165,6 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= 08532ae2-a7b8-4bcb-ba9f-c6a7a22fe36f - true i_breps i_breps true @@ -3195,10 +3193,9 @@ - + The execution information, as output and error streams e73efe6e-ad59-49eb-837e-2c03904e0016 - true out out false @@ -3222,14 +3219,13 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== f4b0de2e-fef0-4b9d-876f-55b17adececd - true a a false @@ -3615,7 +3611,7 @@ false - IyEgcHl0aG9uMwoKCmltcG9ydCBTeXN0ZW0KaW1wb3J0IHR5cGluZwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKZnJvbSBnaHB5dGhvbmxpYi5jb21wb25lbnRiYXNlIGltcG9ydCBleGVjdXRpbmdjb21wb25lbnQgYXMgY29tcG9uZW50CgppbXBvcnQgZGlmZkNoZWNrCmZyb20gZGlmZkNoZWNrLmRmX2dlb21ldHJpZXMgaW1wb3J0IERGQmVhbSwgREZBc3NlbWJseQoKCmNsYXNzIERGWE1MRXhwb3J0ZXIoY29tcG9uZW50KToKICAgIGRlZiBSdW5TY3JpcHQoc2VsZiwKICAgICAgICAgICAgaV9kdW1wOiBib29sLAogICAgICAgICAgICBpX2Fzc2VtYmx5X25hbWUsCiAgICAgICAgICAgIGlfZXhwb3J0X2RpciwKICAgICAgICAgICAgaV9icmVwczogU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuSUxpc3RbUmhpbm8uR2VvbWV0cnkuQnJlcF0pOgogICAgICAgICIiIgogICAgICAgICAgICBUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zOiB0eXBpbmcuTGlzdFtERkJlYW1dID0gW10KICAgICAgICBmb3IgYnJlcCBpbiBpX2JyZXBzOgogICAgICAgICAgICBiZWFtID0gREZCZWFtLmZyb21fYnJlcChicmVwKQogICAgICAgICAgICBiZWFtcy5hcHBlbmQoYmVhbSkKCiAgICAgICAgIyBhc3NlbWJseQogICAgICAgIGFzc2VtYmx5MSA9IERGQXNzZW1ibHkoYmVhbXMsIGlfYXNzZW1ibHlfbmFtZSkKCiAgICAgICAgIyBkdW1wIHRoZSB4bWwKICAgICAgICB4bWw6IHN0ciA9IGFzc2VtYmx5MS50b194bWwoKQogICAgICAgIGlmIGlfZHVtcDoKICAgICAgICAgICAgYXNzZW1ibHkxLmR1bXBfeG1sKHhtbCwgaV9leHBvcnRfZGlyKQogICAgICAgIG9feG1sID0geG1sCgogICAgICAgICMgc2hvdyB0aGUgam9pbnQvc2lkZSBmYWNlcwogICAgICAgIG9fam9pbnRzID0gW2pmLnRvX2JyZXAoKSBmb3IgamYgaW4gYXNzZW1ibHkxLmFsbF9qb2ludF9mYWNlc10KICAgICAgICBvX3NpZGVzID0gW3NmLnRvX2JyZXAoKSBmb3Igc2YgaW4gYXNzZW1ibHkxLmFsbF9zaWRlX2ZhY2VzXQoKICAgICAgICByZXR1cm4gb194bWwsIG9fam9pbnRzLCBvX3NpZGVz + IyEgcHl0aG9uMwojIHI6IGRpZmZDaGVjaz09MC4wLjgKCgppbXBvcnQgU3lzdGVtCmltcG9ydCB0eXBpbmcKCmltcG9ydCBSaGlubwppbXBvcnQgUmhpbm8uR2VvbWV0cnkgYXMgcmcKCmZyb20gZ2hweXRob25saWIuY29tcG9uZW50YmFzZSBpbXBvcnQgZXhlY3V0aW5nY29tcG9uZW50IGFzIGNvbXBvbmVudAoKaW1wb3J0IGRpZmZDaGVjawpmcm9tIGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzIGltcG9ydCBERkJlYW0sIERGQXNzZW1ibHkKCgpjbGFzcyBERlhNTEV4cG9ydGVyKGNvbXBvbmVudCk6CiAgICBkZWYgUnVuU2NyaXB0KHNlbGYsCiAgICAgICAgICAgIGlfZHVtcDogYm9vbCwKICAgICAgICAgICAgaV9hc3NlbWJseV9uYW1lLAogICAgICAgICAgICBpX2V4cG9ydF9kaXIsCiAgICAgICAgICAgIGlfYnJlcHM6IFN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLklMaXN0W1JoaW5vLkdlb21ldHJ5LkJyZXBdKToKICAgICAgICAiIiIKICAgICAgICAgICAgVGhpcyByZWFkIGJyZXBzIGZyb20gUmhpbm8sIGNvbnZlcnRzIHRoZW0gdG8gREZCZWFtcyBhbmQgREZBc3NlbWJsaWVzLCBhbmQgZXhwb3J0cyB0aGVtIHRvIFhNTC4KICAgICAgICAgICAgCiAgICAgICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgICIiIgogICAgICAgICMgYmVhbXMKICAgICAgICBiZWFtczogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sOiBzdHIgPSBhc3NlbWJseTEudG9feG1sKCkKICAgICAgICBpZiBpX2R1bXA6CiAgICAgICAgICAgIGFzc2VtYmx5MS5kdW1wX3htbCh4bWwsIGlfZXhwb3J0X2RpcikKICAgICAgICBvX3htbCA9IHhtbAoKICAgICAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgICAgICBvX2pvaW50cyA9IFtqZi50b19icmVwKCkgZm9yIGpmIGluIGFzc2VtYmx5MS5hbGxfam9pbnRfZmFjZXNdCiAgICAgICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10KCiAgICAgICAgcmV0dXJuIG9feG1sLCBvX2pvaW50cywgb19zaWRlcw== S @@ -3638,7 +3634,7 @@ - iVBORw0KGgoAAAANSUhEUgAAAOEAAACWCAIAAACn9nhUAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAACVzSURBVHhe7Z0HdFTX1e/FzEjTNKNpKpTPjo39EtuJneS9JM/Jc9zzOU6cvGUbHNuJIYHEgLExXRiDwDSBCkICISSBeu+9Cwn13stUjcoUVTDYyZe3vkTvP/cOY82IIoEsXYm713/dde6++5x7R/Obvc+5U2RHG22LwCZpo42q9g2jgw+SjY6OFhcX5eSXqbTXuuRGUo2tGkubFkVEM0ozSnU98Izm0YxSXTSjl2lGKS6aUZpRqotmlGaU6nrgGc2lGaW6aEZpRqkumlGaUarrQWc0m2aU8qIZpRmlumhGaUapLppRmlGqi2aUZpTqohmlGaW6aEZpRqkumlGaUaqLZpRmlOp60BnNyqEZpbpoRmlGqS6a0VKaUYqLZpRmlOp60BnNpBmlvGhGaUaprgeX0fHx8crKCppR6usBZVSv1yGPnj59Oj2zWN3/peXPQTNKQT0QjA4NfSPSMTo2vnPXzmeffbaguIpmlOJayoySUA4MDmr7h9R9OoVa36s09CgNSs1YTX3vy6/8qrGxIa+okq71FNfSZJTMl31anVxl6FYYu+XGHoVBrtIr1XrAqh0wDA4Z1qxZs/7P6wtLquk8SnEtNUYBJ6Tp03UrDEATXKLdP2BilkyrJg0OjIwMt7e3//GPf8zILqUZpbiWFKMgcWBgCAUdD0yl1qNNQjndBgYGvvzyy7raWjBK13qKa+kwChaRL1HZMeNE45ZoTjXT/dGioozsEppRimtJ5VHUdyRRwHlXQGE0o4tFS4RRQKkglkfm/RmYmdEsmlGqaykwCkC1/UN4MNjOJIOSBkaLaEYXg5YIo3KVAZo5oDA6jy4WLQVGsX7vlhv7tLNIojCa0cWiRc8ouOzT6sDowIDZM0MjGU2nGaW8lgKjKo2+h1jOz8roPLpYtBQYVar1s52MwmhGF4uWAqMKtR66B0axrqdrPfVFM0ozSnXRjNKMUl1LgVHMR3tVNKNLVkuBUXWfDut68/6MjWZ0sWgpMGq6Pzqbd+pJMzOaWUwzSnEtfkaJr4J0y439/bMr9jSji0WLnlHYwMAg8qhGq5vVlJRkNI1mlPJaCowCzV6VASsnmtElqSXCqGlpP8u3Q2lGF4uWBKOmr4CaviUyq4+V0IwuFi0FRmGmj+cpZvfxPJrRxaIlwijIRK2f1ZSUZnSxyIrR4bkwvV5vpmAeDWiqNfoexSzu5NOMLhZZMVp435afn9/V1bUgmJq+uDybrzTRjC4WWTF68f4sNDQ0PDw8ISFBq53l9zbmyHqUBpVmpndJSUZTM2hGqS4rRv1mZmemGHb9/f3JxunTp8+fPx8fH488Ov+pFGgC0Jm/cU8zulhkxSiJ3VQDfySCUy3gpuEQtt7e3r6+vvAD0+DgYB8fH+yOjIzMcyrFyfqJbzBjO5MT04wuFlkxikRoMQAH2k6dOgUEzS7CwOIXX3yxe/fugwcPHiFsy5YtHh4e4BVoIo+i6L/66quenp7Xrl0z4zBfBjRnXu5pRheLrBgFZKSBRaB5+PDhnTt37tmz58SJE2R2hIHdHTt2HDhw4KOPPgKp2wk7evQoyTS2BQUFxcXFv/nNb65evTrfqRTlnnzDiWZ0CcmKUXAJA2qwkydPIkciWe7atQsIIkECUBzFlsyjcO7fv9/d3f0QYfB7eXmdPXv23Llzv/jFL0D5guRR8gdLyB9zvLOZGU2nGaW6rBhFZQdnoBNpEvDB9u3bB0bhT05OxrIdDRjJMcGzuYFe8KMjZgJIuoic//moxXoUBrXm7jfzSUZTaEYpL1tGYUiTZIlHdkQqPX78+IULF7Bav3TpEii8g2EOClhDQkIMBsOC3CKFAU3z50toRpeKrBgFjuAM01DkThTrpKSkxMRE0BkbGxsZGRkUFIQceQdDd5AaGBioUql0Op2Zhfk1oDnDck/X+sUiK0aPEYaJJqahYWFh6enpUVFRKNyYjGKWiZqOQ2TMLQ1HgSkiUeiNRuPAbH/dZu6sR2FU991ldU/n0cUiK0aJW0lmQ8lOSEgIDw8Ho0iN8GAOQB5CAwYiyV2LwYk8ilksVlQAdOHLvdlxa6MZXSyyYhRVnjTMRDExxQT04sWLgBVrdnjIQ2ARC6kPP/wQ6ypASTotBnCxbHrnnXcwnZ3/dT1pQJMs96bfwzf7bmE0o4tFVoya7iHdNA8PD+BIVnCzizBwuXXr1vXr1+/duxdts/emYZIQHR2dm5v7xhtvzP/90almWt3fsdzfZLSIZpTismIUXFoMtE01s9fDAyCCTiz8kUfNrikGrD///POf//znmMhOTEyYcZh3M5d71Z3KPc3oYpEVo8DurgYESWTN+9aGQ5iPFhYWLiCgMDDad7dvj9CMLhZZMbr//gz4YqqKCQBK/ELde5pqpi80377c04wuFlkxuuP+bPv27Z988gnWWFjRL+BMlDScX67SK27/O1Ako8lphTSjFJcVo1fuz8rLyysrK7VaLRWSKNBUa3Q9t/+NnZuM0nmU6rJiFE/bfdrIyAgVAIUhe5J3oEzfHjH7rAxXSzO6KGTFqPnZW0LWffs7UDSji0VLmVHzlPQ2X2gGowUF+SnpJQOGfyj7Jki1dQ1Z2rQooiXOqEpz2zdFDQZDS0vzhZCo/OL63MLa3MIaKC3zMtmgRR0tcUb7tKZl0+3ukhqNxvr6+qTk5NTUNFqU1ZJmlPgWXrfiTt/CA6bjJhu7qaltWpTQUmYURvw0qQHZ9LaQ0kZ5W+KMwnoUhtn+fO6cmE6nQ5Km7f7tAWBUeZcPQH0bhgWZQqGora2pq6uldZ+iGZ170+v1HR0d0TFxKamZtO5fNKNzbyMjIykpKZU1rbrhf2qHbtC6Tz0AjM77fPQmo+096jGbt0xo3YOWOKPf/OCj2TEfBkZTU1Mra9p6aUbnQkuZUYCp6buXfy92n0YzOrda4ozKVffyr+3v08yMVtOMzo2sGB3S6airWYKGaBR6PML5v4FPMzq3smJUpdVSVgMGg2F42PTG0cyMTKK9s/9ft/dvxJoptYJmdI5kxWjGoUMUlYdHypEjjVeumDCdgemIf8aMh2daLc1vEoXRjM6trBgdfuaZmWv0hz+08Xx7GnnqqaHnnkvy8Og3YHJ5F+hwHIB29i5AlSeNZnRuZcXokKvrDKVzde1zcdG7uhpcXcfc3NAwEk6bsJkIfSEbp60kEsPjj2fs368hvnJqZsHaQCOIxFxArtZ3yu/0jdBv2yyMymlG50LWjK5aNUMNr1qV4Oxc5ebWu2JFkrNz/8qV3StW2MTcToOrVulXrTKuWjVCNAZWrlSvXIldtHVEANqjRBhk7oUXw5NPxu3YodXrh0dGLL92RnJpYnHI9DE8pVqPh9SjNCxIibcYyegVmtE5khWjgytXzlBjq1YFSyRnxGI/sfiAk1OsTHbUyanQxQXY2UROl27lSuWKFdWurpnOzoiPlUpjZDLNihVwkkfr3dySZDLD1F4uLld/9KPPXn75jbfeUqpUWD4BBXAKLjVaHdAEl3gw2CJ94tACAgozM1pFMzo3smJ0YMWKGWp05cogglF/sRiwRkulmTJZokw2tnKlTaSNdGBx+XJPkShEIvFwcoqTSg87OR1ycsIuOWCes/NuofAzoXB45cohS0dn58HHH6/09t7hvnfXns+No/8FHLsVRlJylUGl0ZNvJi0snaTdZLSVZnROZMVo//LlM9TQ8uVNrq4ZMpncza3axaXe1bXHza3TzW1wWqSNENC3fLmPSBQsFodKJOdAuUi0XSAIl0guSiRIxu4CAbahYrEBaFo6ymRgtMzTc+uO7fs+8xib+DtWRX3aIeRRZFMSTQrAaTaa0bnVPTKqXb5ct3z5CKrz8uV6oo0GBL9NpI2AndrNLVcma3F1rXJxqXB2TpNKO11d82QysN7l6poslba5usKvdHP7hlFn57Ef/GDfCy+8/d57ao3aYDB91ZNSXE41mtG5lRWjWje3eVC/m9swMrGbG+CGRoi2kWijMXrzEMK+6SWTDaxenbBtm2501Dg8vIC/ED0ToxmdW1kxOuDm1ufqeldpCVl2B5HwgNEUz9xLKu1/5JG0Xbv6iPdFzSxQ1UhGyytpRudGVox2uLiQqOmAnatrP6FB4g4l/HBiF36Dmxs8GiISOQ+92omOiPyGqrkVGP3Od1K2b7/D/VHq2BRGx23+3LTuQVaM1shkJIWNMlkHZoQuLj3OzvUyWS1KratrqVSqwpTRxSVMJMqRSIApoKyUyY4IBNi2Ozs3yGR9Li6ab0MSifahh1I+/VSzGPLoqInRlPthtFsx3KMcsXFC8JONWx61CGFkpCXe4p+6e1fdbpyZyNL3/mXF6EUnp2uurrli8Tou108oPOfkFCkSnRUKA4TCE0LheScnk1Mo/MzRMUIkuurqClJ9id04kQiNZLF40IatWUrt4gLK+4mG1SGJpG/VqvQdO5CjKM4o5so3rl/Pzc0rq2i5Z0bbuoZa2vt7VaOExkAkpg0klwrNRGevAQFo9yhHFRqrU2AX8W1dg4ghKUEDHdEL7Y4ePS7Jgo66/xrZHc6p0MOJXUKjZHdscSWagS8tYWhgTARgNFwbtoq+CcSYGhrTKdo6By0DWuK7FSO4PPJxkZekunkN5ElxJeQVqge+RCTZ14rRC0Lhf7m6ZohEu/l8kOolEIQ6OZ0RCoOEwiOOjmjDkyEWZ4nFgPJrV9dMoCkQ4BDgDnZy6pTJtM7O6rtJ5ew84Ow8dHO3z9kZvUx3QAknjjZJpZop8SaJxQMPPxz03nstXV1j4+NUXjONjo5WVVVt3PjX6rouuTVAM5SybyIsMuWkV2BJWXNDs7qqtrupTVtT33v5Siv8ZZVteC79Ai5W1HR29OiwtXCDp7b4cmN9syo6LjM2IVfZdzUhOb+5XQugC0vqr1R1hEelXqnubG7vRxcEJ6YWFBTXAZfSKy1NrX0ADoPgUGVtV0tHf5fcEBmTnpFdlltYU17ZXt+kionPbmhRIwBqbNUUljbUNSnBfU2DHFeCoarre0FheVU7gEMwpO7/khyztXMwr6i2pWOgqq4b8bUN8qLLjeiblFpYUFKPgCvVHbhOnKisog3B6FtRbX5oVowWisVnBYJisbhCIqmWSBQyWZlY7CcQ1CGNyWS5IlG3TNYjk8nRJiLB6BWJpFYi6ZRKO6RSxKtmICzSyyUSnAtjYrdNKm2XSislkhKx+LJYXCaRRDg5IWZqF5VIZHjssQPPPffsCy80NDQMz+zTT/NvBoNBqVS+9tprmzdvqWvsvbc8igSTnl2G5/tcUGRUXGZ8Ul5kTAa2sQk5gReiz56PwBOZkFJQWt7sfy58x67P84tqldqrKu211IyS88HR2fmVePrxHPcN3jjtHwogomIzwiJT84vqTnkHgnLwBy5B5O49HqkZpQiOiE6PS8xFssQghSUN27bv8z8bBtADAsOTUoui47MysstB0s5dB5rateiI5JecVuzlG5SYUoAT7dpzMCu34sgx30sRyRhq26fuGA0vHiCOa8AjwukiotMuRaYgPi4xB6+NM+fCDh/xyS2o2X/wREZOeXrWZZwU3X1OXzjlcx6vCjwuvHLAeq/a+ndK5FJpo0TSJZUOESRhpQJPu0QyAEqk0kGZTCOVqpHkZDJsEQku4UQk/HAiRiFFL/GwhAcNSYVKqUwplU4VxqyXSHwEAggvBqNMFuPkdMrRMVAgOMDn7+PxkJjjwah1L6WTk8LFpdHb+6Sf39atW7/++mszFBQzJNHc3Nw1a95uaWktvdJ8b4wCuIsRSWfPRwLNmIRsoJmUVnT0xBkv3/NInxdC4nILqk+cCsCzHhQS63smBDSg2gKvlPRieHIKqsIjU48e9wNzR46fBi4AHUMhle7eewiUKzSm0oz40LCkC6FxaZmlgDg6Pptg9Cqyo8fhU0hvcJ4LigLTQAc4Ipd7ep0DrHL1KMJwDf7nwsCcl8/5XXs8Qi4l4EQ4S2BQlKfXWQyCkx76wgsnMuVdgtGImHS8tPCI4hNzgy/GhUel4aHFJeWiL0A/7ukPWC9FJiPZ45LwYsNoFTVdqBtWjColEnCGreKm0AaOll2LyEjVNL9W4lQie2y/2+8OuP02yfkZvYSvkYimBqglkmax2MfR0dfRsUosNkil8UKhF58fJxQmCYWRQiEOJTk5YQI6tZcCnuXLU7duffPdd729va9fv26GgmJG/j7wmjVr3np7TX2T/N4YxZOKepedV4lGZW13eWUbnHmFNSj9JeXNSHuoiVl5FSj9qIlExdQBBVNfxXBuYTUSMDIQSEVdxiCovCjuOfmm3aq6Hks8Bke9zi+uQ7uotAEzBLLWYxaIPI3si7oMEFGaARyGRVhpeUtlTReSIvgGRl8c88WYYBcTDMCEE+Gy0QsXiQkG0jzOjpkxeS54cM3tqOZVHZi94EoQXF3Xg2k36gA5OGYOqO/wY4aDuU1xWVN9sxp/AStGrbCYIguLIMzivKUGxY45sifsHrlk953o1au+KBI92ubkrBKJFWKxJQaDNIjFjSIRoPTm82tFIrlE0iYWd4vFXWJxB9GwBJvl5DT08MO7f/zjrbt26Q0GivxU9C0N8xC1Su3hcehKdfu9MQqhI2aTeOZADLkiwSQVhY8UdpHJEIPnHn7skr3IMDCEeTC64ygRZlpswY8tumAiYTkLoCR3MSYJKClThTVNBky9cAGIwWgWPxnT3j2Elwp2IYThLIRMl4R407k04zi75drI0bCLMPJBIZg8C+Lhxxa7lkGIGLIxasWoXCyeLuDVjJmoWNwrFteJRH1isUos1hAi21piS7blYtGQiPeR69t2D53nrvD5idvOnc+8UbtqhYYnUAhE5IAYB5FYBnWJRB0AVCxWEsKJLA0y8hsJhZh1pGzZMnrjBhil8poJ13bt6tXs7JzL91rrF4VAFQCycX5LsmK0VySaLrlIVCYUdhINXx4vTSBocXIqFQqriG2Tk1OGQNBItBswaxSJDfxlYY+9zljbz3pb+6O3C7eu+e25P/ww7w8PNT7prOQ52YwMTfXcVgIBGE382980ev2iuD+anJxy+T7uPdGaKitGe5ycpgt1NojPbxYKlSLRSR4vgMc7xOX68XjbOBzIk8c7w+Md5fEOcrn5AkG/0LFTJHlmbaPdzsn/2D35/tYMj4/W+xx471LAjzP2PNQlcuoV2I4/Izk6Ivsm/vWvi4PRUYLRKzSjcyMrRruFwulCnb3I5zcJhQqhEGj683inudw8geAElxvO5wfyeCe53BAez5vLvcTnj/CYCY++KP3z8Hf/rP3dJ8qP9+UePxoR4e2ecfaprPjVDW+59joIbMafkfj8HpEoccMGjcFAM/qg6e6M9giFbQJBBI8XzOPVCgSVjo5dQiHULhDUOjpG8XgpfD7CKgSCDqGwV+DYJHatcH60bNXT2z9K3uZb6HP6bF3A/x259NTfc77Xv9al096KUYzTS5wCbWzRhodsW2JMIk6R+uGHhqtXaUYfNFkx2iUQ3FI9AkGro2OLoyMacoGgmxDaCoGg+WYA6e9E25Gv4TCapW5JP/1d9k9eLt/02lDKi/8seeYfZx7uFgo6eaZ4pUCgJjqiS42jI3r1AXGirREIVDcHRAwaONrF4yklklMvvlhQXj4xMUHxz+aRjN7z/VFaNrJitBO43EZdhGycUPet/YJuPk/JspMzlvX+dnW/+/fHDz2i/p/idiYfRzG5zOTxEng8tHsdHYv5/BI+P4rLrSAaOJTL4/lxOBe53Cwerw4ZFAPyeCqp9MQvf/nsSy8VFhaOj42ZcaCkgdEkmtG5kxWjHXw+KWABktAAQ503nfciDMLjd9hz21m8dgcCUD7/Mp9/is325XAyudwhR0fguJ/NDuZwDrDZ/hzOSTb7NNEO4nA82OwSHg/X0MHltrLZLceOBYZd+suGTdeu/wMoUPND+DAzo+U0o3MjK0Z7+Xwln6/m86t4vDIer4/Pz+Vy23g8gIVq2w5ciIAuPl+BRQyfLycaEDzww4MYW3FvithFRmzg8bzYbGBawuVihNNstg+xG8hmh3I4qVxuNpd7lmh/4eCQwOFg5HYOB0U/+Pe/f+k3r18IiezXfdVj+k8MC/kF5TsYzejcyorRdA4ngsOJ53BAxkEHB7Diz2YnczhVXG45l9vD46WhBLPZNVxuBEEYwqI5nBgOp5bLDWaz87jc7ql03kbAvZHLbeZyMRooPGBvj5cBRoC/lcdDG0IYPHVcbgfZi8OROznte/pp/5CQsfGxgcEhBfFDDyrNbf+t8gIazejcyopRfwcHQHPQ3n6fvT3aXg4OJxwc/BwcTjk4lHM4vVwuGpCvg8OHLBZiAhDs4HDcweETe/s/sVhIhArk3RkItZsUYAWInUS73VpkgLkLm93KYiWvXz/29dfkuh5o9mlNv+ikvM2/WlxAMzGaRDM6Z7LOo2x2JpsdjeJL0AkEE9jsWDYbqa6VwynjcOLY7AI2G+wC0CA2O5vNTkSAg8NpgtRSDqfLQtXMRLLYOs1vKza7jcWKfffdvuFhy70noKntH6JgNiUZLaEZnSNZMYqS2kaog8NpJhq9HE6gg0MWKj6bfc7BoZ44BAFZMpjcdnE4TUQX+L8VOTi0Mpmx77wzlVEYmU0X8OfHbmlmRstoRudGVoxamCBJJdvgEiCCS4BocU4NsHim7s6xwCiDEbt2rQ2jMKCJPIpHMoBZqtm3wEbn0bmVFaMtbPZ0mW76zIua2ewONrudaNgcanFwaLKzS3zvvdGb89GpBkx7VYbb/X/l+TeC0eSSsiaa0TmRFaPNDg7TBT4gS7tzyqF7EwbpIoTs2EQM2I65rIOD3MEh094+y95eRTjJAHMve3vs7v3ud4MiI8cnJsws3DSgiSTafcf1k8FgGJm9GY338v8e6Fo/t7JitMne3kYt9vZV9valRKODwCWKxSKpwrbbwaGHaOAQGm1gbtoINgJtUCiLFcBi1dnbd9rbR9nbR9vbp9nbp9jbb2Iy/VisQBYrksUKYrFK7O3byI4sVru9/ZkXXvjlr38dHRNz9eqEDYvY7evXmX529FY3TQFoY2NjSUlJ2WystLS0urparwf3s0vQdB6dW1kx2shi2aiVxSpisbLAJYt1mcU6zGRuZjDSWaxsFisGPDGZPkwmqE1ksU4wmYVEvM0INsLyPI/FOspkejGZSUymxt4egxxnMncyGMeIxnoGYyODgaP7GIwkoEl2ZDJr7Owa3d2DIiM++PPmkYn/p572G45omyamvba/L45cWFNTk5aWVlFRUT4bu3LlSmFhIWCd7cf+wWhiUnIxzegc6S6MdrBYcUzmeSZziMU6SRC5hcHwZDLR/hQNBmMvgwGwwK43AVbPtBFshIxYz2KdRjyTmcNk5jOZEQSv4UxmEJN5iMkMYTJ9mcxsbLFIYjItjKJx5IfP/OT559MzcoYM11DZuxVG5E4bTBVq0w+Rage+wXRsbCwrK0sul4+Pj6N8j46OXr9+/caNG2iQBf12Njw8/NVXXwHTqqqqWRV9DJyQmFRSTn/uaW5kxWgDk2mjFmDEYEQyGMXIl2CRwQhkMC4wGJ8zGCEMRhowYjCiGYwDhCeXyWydNsJ0ATiEdTCZiQyGP4NxBfwRHgina2Mym4mwJmK3nuzFYKDt8f3vZxaXTExMDJl+H3cQs8/OXhT36Zia/GSiNRpNX346e/Zsd3c3sB0gLCUlJT4+XqPRkJ+fMhr1pAwGFPZvDJi2t7cXFRVptbN71xWMpqamZeRcUfdf71GN0bpPWTFaz2BMVxuDkcdgnGIwshiMDgajlcFoJrZQE9FuAcTLltUSDZu+dxbiMXjjFA9YtNmatWwZan38m2+OTFnXAxu1xnRz1Ka4k368/uTq4T6t/r333lu7di2IxCFMTNPT06OiojIyMpBZ4ZHLexsaqhobq6GGhmrMCkjDTLSlpQUV//Lly4CVGHimptfrlEplRGTshZCIkNBIWvcpK0Ybly2broZly1qXLesmtmjbHCXVsmxZ0zTn3KrBzi78V7/qGx21uYePrImib5Pl4B9AuTdcC49Ke//9P7YShnQIRsPCwsCfv78/lkTXrhkTE6sffkT+6GMDqx4aeP236paW+sbGBhgyqK+vb29vL/Io4me7wEca1umG1GqVRkPrfmXFaKGdHTVVZGeXYWcX9cEH+i+/NAE4xcAi5qbT/7My9jClREZ85ZVX/Pz8UOv7+vpQ3OEBoIGBgfX19cPDQxkZVRs3Dm3eMv63v40dPTY8OKjRapR9asWw0Xju3DksmIqLi5EU7+3b0kjvtN2/WTGa6O5OUe3enXToUE9HB6aN5uf/ppGp1HQD3yaXEoZ1UkxMzAcffABGUe4VCgWyaRdh2NVo+srKSpubS7q7q+Ty2u72yoAz/h9uO7jpoy8uBIZ4e52Mi4/HggmDkDNX2hbErBgdvnGDmjLeuDFy44YJ0GmsgEzMR5FK+wduASnYwto8NzcXWRPpEHNQGBpkG5CilGdnZ5eUll4uKNiwffvLnx9fFxr6tp/nixv2vvr6uz3dneiL0o9JgnlE2ubdrBg1+xabAVtMSW/3T8OGh4dTU1PBKKDssTaVSpWfn481fn5O7vbP3H97/qxx8t81f4870vf81ivrXtv8l8aa+ry8vM7OTswvzcPRNu+2FBgFmqj1t3wjFHl0YmIiJycH01BAiTUQuEShV6vV2EXpx6FLly7Fhl58+pMNnrrakcnG+K/f9Zl4fFfvM28e+k1CRBJqPfW/5be0bYkwCkCnT0kBFpIoWDx06FBdXR3ozMzMDA4Ohh/LpoqKCtITEBBw7sSpR/Zve2XQ58TIr09OPH5yePWfG1e/vOe5pqqWrKys1tZWOo8uoC0RRlHoUe5tch3A0qjVb7zxxrp165qbm5E7sX5CG6nx3XffLSwshCctLc3LyyvgxMmnt3/k1uP3Tv9rH2mf+aD98Z8VPPmzna80VTYC4paWFno+uoC2JBgll00K07LJkknRGh+fiIpOWLduPYr75cuXkTVjY2P37t2LtPr5559jook1Eyaj77///ocbNvyfV16xP7jp4cA1T5784WOHn3De/9P/tfGt+PBoTBLodf3C2lJgFEYumyyfxscWbYVmvLqu+5VXXnV3d6+tre3u7sYSPjExEVwmJyeDWiyGkFMBbmxcXGJcfFJUTEJ0YkJ0UkJMMhpZGVm1dbXp6emYxVL51ySXvH0rjCLpoDiSH8uYjRnRZWxiZGTcMBONThiNw0birXtTKrUsmyCVxvQ5PWxHx8ZKSko2bdpUWVmJko2ZZXt7e0dHR1tbG3YbGxvhAbvfWJdZPdh0diISACOM6rV+YECn1+Mvoh8Zn60MI6PmQahq3wqjRqMRBODZjYkx5agZKj4+ISws/IJ/eMzFlKiQpLsoOCkyNKGhod5oNNEDLm8umwZMgFq+4TQwcOPGjYyMDJCKS2qajYFjJF3APTY2RvFar9MbVHJFYfSl/IsBBWHnZq68kDOV2em64dEhnWWWRDmbe0ZRFlUq5fnzIbGxGXFxWUlJeYmJubGxmVMVH58FkQHE0Qw4E5NyA4ODP3s1xefx8ROrRz3vqBOrxzwfM/hsSevXq8h/H0pMSU2ptEsOQIdMgBKG3JyTk4PVUnl5eWlpKUr8DA3xKPSRkZGYyFK61uOxGkcKQ08PXPr9tfj/vBb3OvQlIbJ9B12N/09lxLrqrMSBIb3phU5Jm3tGURZbWprPng1OSSkJD09zdz/i4eGdkFAYH58fF5cHJSYWRURkRESkJyUVhYWlnThxNiWlNDo6OzYu92Jk5OFfVhyxmzxgN3nwjkLAcbvJfS9kRCaEXr06gSyATEd+3NDmk3TYQRYk74OGIVHPxqKiooKDg1Hr7+1LI/NjeICj49fLgo9MJv3vydjHJmOfmEx60rSNeWIy7m6KWT2Z93rpuX293XLMFswjUsy+FUbb2lr9/M4DyoCAiPXrN4NCH5/g48cDvLyCPD3P7dt37MMPt2/ZsuvYsTOffXZ8zZo/7dt3NCwsJSo683xo6IFny47ZTR66mzzsJj2Zk/tfyv7Jz3905oy/ceQ6kigA7VXeAiZcEko2Kj7WTLMydKmvrx8dpfSMbXxiIjouyWvjG/9OfX4y+onJhKe1/t+L2LSq5vDqf8X+YDLm6cn4JyaTH51MWj2ZvHoybvVk1GOT0RAa35nM+EXthV1tDc2G4dl9/nA+7dti1NvbH8kyNDT5yBG/des2bdiwde3aDzZs+Hjz5l0vv/w6PBs3fvLXv27z9g7+y18+AseenoGRkZlnAs/v+/HlGTJ62G4y4J2Wysbi5198VakZ69MaTJ+BUth+8w7X09zcnJaWhqKPlAPT6/VYoKF8k7t3MPStra3FDIGy9/DHx8cxIfnZz58Pc1//r6RfTEZ999+x30/99KE+38crPR7974inJmO/pwt8ruL42hrPt6uOv9174S1D/Ju6mDf1sW9qI37fF/RTedjGhuKCIT2m9Q9SrW9vbztxwvfixZSAgMht2z7bsePgnj2Hd+8+tHs3toc3bvzY3f0o/B9/7L53L2YCXgcPeiHFhl5M9j7jv/vJ0pkwCh1dNnn4pbI/bfjDps2bJyZM5Z6clWLBhGUT2hCqPA5h8Z6fnw9GsWu6sa/RIK0qlUpQiAvW63WY0ZKyMaCMlVZBQQHa5KOjmn311Vfbtm07fuq0viT6n2HPTEb+j3/HPpXyyX80fvHo+fXLJ4K+N5m2wu8vRx0kk2K3/+aI/vWF57huRNur1sn7DJWt/aGf/nQy4yclvh8vmlpPG23UNDOjtNFGXbOz+/+bQS4VlFURaQAAAABJRU5ErkJggg== + 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 From b88d8529358819e5738bec0a91c437c0992e6155 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 15 Apr 2024 17:01:23 +0200 Subject: [PATCH 047/141] ADD: basic instructions for pyhton ghplugin --- CONTRIBUTING.md | 61 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index c24de844..ff5be3bf 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -49,7 +49,64 @@ git commit -m "Remove a submodule name" ``` --- -# PyPI +# Python +DiffCheck is distributed as a Python Grasshopperr plug-in via yak and its source code via PyPI. The plug-in is composed by a series of `.ghuser` components. + +There are 3 ways you can contribute to the Python GH plug-in: +1. By adding new components to the plug-in. +2. By fixing bugs of existing components in the plug-in. +3. By adding new functionalities to existing components in the plug-in. + +Before committing to the repository you need to have tested the components in the Grasshopper environment and be sure that this is working correctly. Also, provide a sufficient documentation in the PR (for now) please. + +Follow these steps to develop and test the Python GH plug-in: +- [GHPy: A) preparation](#ghpy-a-preparation) +- [GHPy: B) development/debug](#ghpy-b-developmentdebug) +- [GHPy: C) Release](#ghpy-c-release) +- [GHPy: D) Documentation](#ghpy-d-documentation) + +## GHPy: A) preparation +Download this repo if you haven't already. +```terminal +git clone https://github.com/diffCheckOrg/diffCheck.git +``` + +Next, if you used diffCheck before as an end-user clean all the `diffCheck folders` in the following directory (the last name will change): +```terminal +C:\Users\\.rhinocode\py39-rh8\site-envs\default-wMh5LZL3 +``` +> note that if you drop an official released diffCheck component from yak, this one will have the `#r : diffCheck==` notation at the top of the script. Get rid of all these release components before to start and be sur to erase again the previous folders (they recreated each time `#r : diffCheck` is called). + +Lastly, install the pip pacakge from the repository in editable mode. This way, all the modifications made to the source code of the repository will be reflected in the installed package. Open a terminal and run the following command (replace the path with where you download the repository): +```terminal +C:\Users\\.rhinocode\py39-rh8\python.exe -m pip install -e "\src\gh\diffCheck" +``` + +That's it you are now a contributor to the diffCheck! We raccomand to not download anymore from yak package but rather use the source code in the repository. If you want the latest diffCheck, checkout and pull the main. + +## GHPy: B) development/debug + +### Code structure +For DiffCheck there are 2 main folders in the repository: +* `src/gh/diffCheck/components` here you can add new components or modify existing ones (for more info on how to create one we point you to [this documentation](https://github.com/compas-dev/compas-actions.ghpython_components)). Here we call the +* `src/gh/diffCheck/diffCheck` this is our package where the core functionalities are implemented. + +### IDE +We reccomand to use `VSCode` as IDE for developing the components. This is because it has a good integration with the `Grasshopper` environment and it is easy to debug the components. To set up the IDE follow these steps: +1. Install the `ScriptSync` extension for `VSCode`. +2. Install the `ScriptSync` from the yak manager in Rhino. +3. Open the `code.py` from the `src/gh/diffCheck/components` folder you are working on in `VSCode`, and set its path to the ScriptSync ghcomponent. +4. If you modify the code in `VSCode`, the changes will be reflected in the Grasshopper component as soon as you save in `VSCode` again the `code.py`. + + +## GHPy: C) Release +The release will be made via CI from main. As a contributor you don't need to worry about this. The plug-in is componentized, pushed to yak/PyPI and the user can download the latest version from yak. + +## GHPy: D) Documentation +More to come. + + + --- # C++ From 15f8fb39baead35ab4ac7d150c14ed219fea21f6 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 15 Apr 2024 17:02:14 +0200 Subject: [PATCH 048/141] WIP: saved before integrating release pipeline --- src/gh/tester.ghx | 763 ++++++++++++++++++++++++++++++---------------- 1 file changed, 498 insertions(+), 265 deletions(-) diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index 5d0e9d93..e0bac28c 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 221 - 94 + 249 + -620 - 0.72582066 + 0.7830095 @@ -634,60 +634,6 @@ - - 59e0b89a-e487-49f8-bab8-b5bab16be14c - Panel - - - - - A panel for custom notes and text values - 63a2f4e1-c253-4fc3-9148-719323b802e1 - true - Panel - - false - 1 - 3b1f5a65-4f18-4dc9-ad6f-bd8872256cbe - 1 - Double click to edit panel content… - - - - - - 627 - 305 - 748 - 153 - - 0 - 0 - 0 - - 627.5534 - 305.93573 - - - - - - - 255;213;217;232 - - true - true - true - false - false - true - - - - - - - 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -739,7 +685,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -858,7 +804,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -977,7 +923,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1014,7 +960,7 @@ - + a8b97322-2d53-47cd-905e-b932c3ccd74e Button @@ -1046,7 +992,7 @@ - + 06953bda-1d37-4d58-9b38-4b3c74e54c8f File Path @@ -1103,7 +1049,7 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -1155,7 +1101,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1192,7 +1138,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -1310,7 +1256,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1347,7 +1293,7 @@ - + 919e146f-30ae-4aae-be34-4d72f555e7da Brep @@ -1428,7 +1374,7 @@ - + 06953bda-1d37-4d58-9b38-4b3c74e54c8f File Path @@ -1486,7 +1432,7 @@ - + a8b97322-2d53-47cd-905e-b932c3ccd74e Button @@ -1519,7 +1465,7 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -1572,7 +1518,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -1694,7 +1640,7 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview @@ -1816,7 +1762,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1854,7 +1800,7 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch @@ -1892,7 +1838,7 @@ - + c9b2d725-6f87-4b07-af90-bd9aefef68eb 066d0a87-236f-4eae-a0f4-9e42f5327962 @@ -1900,7 +1846,7 @@ - + true 2 @@ -1908,7 +1854,6 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= 0bc1d704-d9a5-496a-8097-0e77a2179817 - true true false true @@ -1918,46 +1863,45 @@ false false - true + false - + - 248 - 371 + 291 + 992 171 84 - 355 - 413 + 398 + 1034 + true - + 4 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa - 4 - 3ede854e-c753-40eb-84cb-b48008f14fd4 + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa 08908df5-fa14-4982-9ab2-1aa0927566aa - 08908df5-fa14-4982-9ab2-1aa0927566aa - + - + true Press button to export xml iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= ff7bc6fc-cd70-4c56-8f79-fc4cbd06681c - true i_dump i_dump true @@ -1970,30 +1914,30 @@ - + - 250 - 373 + 293 + 994 90 20 - 296.5 - 383 + 339.5 + 1004 + true - + true The name of the assembly to export. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC eac6f337-07dc-4148-804b-ee5f29e1c0f7 - true i_assembly_name i_assembly_name true @@ -2006,30 +1950,30 @@ - + - 250 - 393 + 293 + 1014 90 20 - 296.5 - 403 + 339.5 + 1024 + true - + true The directors where to export the xml file. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 0341be27-157c-4fa0-8841-4876c4aa61b9 - true i_export_dir i_export_dir true @@ -2042,23 +1986,24 @@ - + - 250 - 413 + 293 + 1034 90 20 - 296.5 - 423 + 339.5 + 1044 + true - + 1 true The breps of the structure. @@ -2066,7 +2011,6 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== f7f134be-ff73-4607-8432-4027726d7c9a - true i_breps i_breps true @@ -2079,57 +2023,30 @@ - + - 250 - 433 + 293 + 1054 90 20 - 296.5 - 443 + 339.5 + 1064 + true - - The execution information, as output and error streams - 3b1f5a65-4f18-4dc9-ad6f-bd8872256cbe - true - out - out - false - 0 - - - - - - 370 - 373 - 47 - 20 - - - 393.5 - 383 - - - - - - - + false The string of xml to be exported. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 63fce5d6-5cca-4c37-978e-16ad72dccdf6 - true o_xml o_xml false @@ -2141,30 +2058,30 @@ - + - 370 - 393 + 413 + 994 47 - 20 + 26 - 393.5 - 403 + 436.5 + 1007.3333 + true - - + + false The breps of the faces belonging to joints. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC d876ac7a-afbf-4696-a6c0-6b8d5230d058 - true o_joints o_joints false @@ -2176,30 +2093,30 @@ - + - 370 - 413 + 413 + 1020 47 - 20 + 27 - 393.5 - 423 + 436.5 + 1034 + true - - + + false The breps of the faces belonging to sides. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC cd81b022-0563-4d70-8ad2-86542a5f5a10 - true o_sides o_sides false @@ -2211,17 +2128,18 @@ - + - 370 - 433 + 413 + 1047 47 - 20 + 27 - 393.5 - 443 + 436.5 + 1060.6667 + true @@ -2247,18 +2165,17 @@ - + 919e146f-30ae-4aae-be34-4d72f555e7da Brep - + Contains a collection of Breps (Boundary REPresentations) true f6905f9e-831e-4c85-831f-4a85822df09c - true Brep Brep false @@ -2266,17 +2183,18 @@ - + - 171 - 432 + 214 + 1053 50 24 - 196.57437 - 444.25897 + 239.74905 + 1065.9746 + true @@ -2328,19 +2246,18 @@ - + a8b97322-2d53-47cd-905e-b932c3ccd74e Button - + Button object with two values False True 508c9c16-1d49-4404-84cc-7cc48c8f273b - true Button dump! false @@ -2348,32 +2265,32 @@ - + - 118 - 372 + 161 + 993 102 22 + true - + 06953bda-1d37-4d58-9b38-4b3c74e54c8f File Path - + Contains a collection of file paths false All files|*.* 3f1b8093-20ad-4b03-90b2-110f234137fc - true File Path Path false @@ -2381,17 +2298,18 @@ - + - 170 - 412 + 214 + 1033 50 24 - 195.9993 - 424.0232 + 239.17398 + 1045.7389 + true @@ -2419,17 +2337,16 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel - + A panel for custom notes and text values a170d6d1-471e-4c64-9806-444e47f21d66 - true Panel false @@ -2439,10 +2356,10 @@ - + - 118 - 394 + 161 + 1016 102 20 @@ -2450,9 +2367,10 @@ 0 0 - 118.27825 - 394.3187 + 161.45294 + 1016.0344 + true @@ -2472,43 +2390,42 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews true e82c0b60-8d4c-487a-8a2a-60ccdfb2c440 - true Custom Preview Preview - + - 544 - 371 + 587 + 992 48 44 - 578 - 393 + 621 + 1014 + true - + Geometry to preview true f483e244-6e89-4839-a140-53b2307e5305 - true Geometry G false @@ -2517,26 +2434,26 @@ - + - 546 - 373 + 589 + 994 17 20 - 556 - 383 + 599 + 1004 + true - + The material override 5eadcdca-b596-4817-b74a-daf84cb33bba - true Material M false @@ -2545,17 +2462,18 @@ - + - 546 - 393 + 589 + 1014 17 20 - 556 - 403 + 599 + 1024 + true @@ -2594,43 +2512,42 @@ - + 537b0419-bbc2-4ff4-bf08-afe526367b2c Custom Preview - + Allows for customized geometry previews true 1cf1d421-79da-445c-baea-160043841df5 - true Custom Preview Preview - + - 545 - 418 + 588 + 1039 48 44 - 579 - 440 + 622 + 1061 + true - + Geometry to preview true f3c7f1be-a13f-418f-bdc3-968772d68045 - true Geometry G false @@ -2639,26 +2556,26 @@ - + - 547 - 420 + 590 + 1041 17 20 - 557 - 430 + 600 + 1051 + true - + The material override 14b44143-7bb4-4e4b-a0c1-8aeb245e6588 - true Material M false @@ -2667,17 +2584,18 @@ - + - 547 - 440 + 590 + 1061 17 20 - 557 - 450 + 600 + 1071 + true @@ -2716,17 +2634,16 @@ - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch - + Colour (palette) swatch 1652822d-91b6-4619-a0f1-929bd813d353 - true Colour Swatch Swatch false @@ -2737,34 +2654,34 @@ - + - 441 - 394 + 484 + 1016 88 20 - 441.1697 - 394.63263 + 484.3444 + 1016.3483 + true - + 9c53bac0-ba66-40bd-8154-ce9829b9db1a Colour Swatch - + Colour (palette) swatch c217b73e-3729-4db1-951f-b5914db0d7d8 - true Colour Swatch Swatch false @@ -2775,24 +2692,25 @@ - + - 442 - 441 + 485 + 1063 88 20 - 442.5322 - 441.6774 + 485.70688 + 1063.3931 + true - + 719467e6-7cf5-4848-99b0-c5dd57e5442c 066d0a87-236f-4eae-a0f4-9e42f5327962 @@ -2997,7 +2915,7 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -3051,7 +2969,7 @@ - + 59e0b89a-e487-49f8-bab8-b5bab16be14c Panel @@ -3105,7 +3023,7 @@ - + 719467e6-7cf5-4848-99b0-c5dd57e5442c 066d0a87-236f-4eae-a0f4-9e42f5327962 @@ -3272,7 +3190,7 @@ - + c9b2d725-6f87-4b07-af90-bd9aefef68eb 066d0a87-236f-4eae-a0f4-9e42f5327962 @@ -3627,6 +3545,321 @@ + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 180538b6-48a7-45a7-9f63-4236e4b1aade + true + false + true + DFXMLExporter + XMLout + 1 + + false + false + false + + + + + + 288 + 888 + 171 + 84 + + + 395 + 930 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + ee32ac69-2980-466c-a27d-24c46e0f978d + i_dump + i_dump + true + 0 + true + 0 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 290 + 890 + 90 + 20 + + + 336.5 + 900 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 7937e977-a894-475a-9126-ab9f2badf263 + i_assembly_name + i_assembly_name + true + 0 + true + 0 + The name of the assembly to export. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 290 + 910 + 90 + 20 + + + 336.5 + 920 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 5b90a98b-2119-45b1-9acc-86618952952a + i_export_dir + i_export_dir + true + 0 + true + 0 + The directors where to export the xml file. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 290 + 930 + 90 + 20 + + + 336.5 + 940 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== + + b2b35e86-d097-457c-8dd0-fa8f391f2d52 + i_breps + i_breps + true + 1 + true + 0 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 290 + 950 + 90 + 20 + + + 336.5 + 960 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + dae952a3-80b5-46b4-83e6-d4a74502350d + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 410 + 890 + 47 + 26 + + + 433.5 + 903.3333 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + f9949a62-8862-4f11-9b42-5d9d2d9760da + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 410 + 916 + 47 + 27 + + + 433.5 + 930 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 5c203e94-0aef-400c-8aec-d20d76f0571e + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 410 + 943 + 47 + 27 + + + 433.5 + 956.6666 + + + + + + + + + + false + IyEgcHl0aG9uMwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKaW1wb3J0IG9zCmltcG9ydCB0eXBpbmcKCmltcG9ydCBkaWZmQ2hlY2sKCmltcG9ydCBkaWZmQ2hlY2submV3bW9kdWxlCmRpZmZDaGVjay5uZXdtb2R1bGUudGVzdF9uZXdfbWRvdWxlKCkKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICAiIiIKICAgICAgICBNYWluIGZ1bmN0aW9uIHRvIHRlc3QgdGhlIHBhY2thZ2UKICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAiIiIKICAgICMgYmVhbXMKICAgIGJlYW1zID0gW10KICAgIGZvciBicmVwIGluIGlfYnJlcHM6CiAgICAgICAgYmVhbSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICBiZWFtcy5hcHBlbmQoYmVhbSkKCiAgICAjIGFzc2VtYmx5CiAgICBhc3NlbWJseTEgPSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcy5ERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgIyBkdW1wIHRoZSB4bWwKICAgIHhtbDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICBpZiBpX2R1bXA6CiAgICAgICAgYXNzZW1ibHkxLmR1bXBfeG1sKHhtbCwgaV9leHBvcnRfZGlyKQogICAgb194bWwgPSB4bWwKCiAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgIG9fam9pbnRzID0gW2pmLnRvX2JyZXAoKSBmb3IgamYgaW4gYXNzZW1ibHkxLmFsbF9qb2ludF9mYWNlc10KICAgIG9fc2lkZXMgPSBbc2YudG9fYnJlcCgpIGZvciBzZiBpbiBhc3NlbWJseTEuYWxsX3NpZGVfZmFjZXNdCg== + S + + + + + *.*.python + 3.* + + + + + + + + @@ -3634,7 +3867,7 @@ - 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 + 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 From cda898549f72d65a62785bfd11a1f9473c15c2df Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 15 Apr 2024 17:26:45 +0200 Subject: [PATCH 049/141] ADD: isntructions without vscode --- CONTRIBUTING.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index ff5be3bf..7156046b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -82,6 +82,8 @@ Lastly, install the pip pacakge from the repository in editable mode. This way, C:\Users\\.rhinocode\py39-rh8\python.exe -m pip install -e "\src\gh\diffCheck" ``` +For your info the packages is installed in `C:\Users\andre\.rhinocode\py39-rh8\Lib\site-packages`. + That's it you are now a contributor to the diffCheck! We raccomand to not download anymore from yak package but rather use the source code in the repository. If you want the latest diffCheck, checkout and pull the main. ## GHPy: B) development/debug @@ -98,6 +100,7 @@ We reccomand to use `VSCode` as IDE for developing the components. This is becau 3. Open the `code.py` from the `src/gh/diffCheck/components` folder you are working on in `VSCode`, and set its path to the ScriptSync ghcomponent. 4. If you modify the code in `VSCode`, the changes will be reflected in the Grasshopper component as soon as you save in `VSCode` again the `code.py`. +If you want to use the GHEditor it's ok but everytime you modify the pakcage or the component's code, after any modifications you need to restart the Python interpreter from the ScriptEditor (`Tools > Reload Python3 (CPython) Engine`) and recompute the solution in Grasshopper. ## GHPy: C) Release The release will be made via CI from main. As a contributor you don't need to worry about this. The plug-in is componentized, pushed to yak/PyPI and the user can download the latest version from yak. From a18986fa95dd04afd3baa6227265dab7aec50199 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 21:26:27 +0200 Subject: [PATCH 050/141] WIP: Open3d ICP added to registration class --- diffCheckErrors.log | 2 +- diffCheckEvery.log | Bin 455 -> 737 bytes src/diffCheck.hh | 3 ++- .../registration/refinedRegistration.cc | 14 ++++++++++++++ .../registration/refinedRegistration.hh | 15 +++++++++++++++ src/diffCheckApp.cc | 18 ++++++++++++++---- 6 files changed, 46 insertions(+), 6 deletions(-) diff --git a/diffCheckErrors.log b/diffCheckErrors.log index 092b5e99..f104f3b2 100644 --- a/diffCheckErrors.log +++ b/diffCheckErrors.log @@ -1,4 +1,4 @@ arguments: loguru -Current dir: F:\diffCheck +Current dir: C:\Users\localuser\diffCheck File verbosity level: -2 date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log index 20fc75ab3c002c6a823ebfd050def47301387949..db78b7876f71cf76d09f829391a126f331532452 100644 GIT binary patch literal 737 zcmeHEyJ`b55KJx5KTLNv@YC9 zv$L9Q87btX;G->Eq-YCsWndgDw5oeg#HsUft9_}kGp_I3fwrGgygE;qh&M60yoaZW zyuz~-MrXoY*^R#tSfG5(#1bFK1CurgdZZ_3u>Mh;x4v#r-i3L@bbu6Z(OMTQazu0T z@={&wAL|LtJ;rEAq1jb<@^*A}S;-tZU6nqpq?prDDh(x@xC@J=6nFpiM*^3VzQvEe E0ivLg=l}o! literal 455 zcmchS&rZWI42SQ1ir=k6q9sj-pt(+~goNM$fJ0c)EFyoZG%1?2hbL3n1Q(9@V#}64 z`{O|+D_xuzj8`e7Vv|D14G0|=diE;xFl_d6_fhoPNX#<4`$@+GjGU!m=nBE3#1c{4 za|x`F#-(wE7sP##T)=TFZ?wSM_r}jO source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index e69de29b..4bec4ced 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -0,0 +1,15 @@ +#pragma once +# include "diffCheck.hh" + +# include + +namespace diffCheck::registration +{ + class RefinedRegistration + { + public: + static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + }; +} \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index bca9a8c4..ad016d55 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -21,10 +21,20 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - DIFFCHECK_INFO("test"); - DIFFCHECK_WARN("test"); - DIFFCHECK_ERROR("test"); - DIFFCHECK_FATAL("test"); + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; + + dfMeshPtr->LoadFromPLY(pathMesh); + dfPointCloudPtr->LoadFromPLY(pathCloud); + + std::shared_ptr dfGroundTruth; + dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + + // DIFFCHECK_INFO("test"); + // DIFFCHECK_WARN("test"); + // DIFFCHECK_ERROR("test"); + // DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From 034cbfd730747ee1ec44ec101ddf991c39a93a55 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 22:56:50 +0200 Subject: [PATCH 051/141] WIP: improvements on documentation and removal of hard-coded parameters --- .../registration/globalregistration.cc | 35 +++--- .../registration/globalregistration.hh | 112 +++++++++--------- 2 files changed, 75 insertions(+), 72 deletions(-) diff --git a/src/diffCheck/registration/globalregistration.cc b/src/diffCheck/registration/globalregistration.cc index a002303e..5d641a73 100644 --- a/src/diffCheck/registration/globalregistration.cc +++ b/src/diffCheck/registration/globalregistration.cc @@ -1,7 +1,7 @@ #include "globalRegistration.hh" namespace diffCheck::registration -{ +{ std::vector GlobalRegistration::ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target) { std::vector errors; @@ -13,6 +13,7 @@ namespace diffCheck::registration distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud); return distances; } + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target, double voxelSize, @@ -21,23 +22,21 @@ namespace diffCheck::registration double maxCorrespondenceDistance, int iterationNumber, int maxTupleCount) - - - { + { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(0.01); - targetO3D->VoxelDownSample(0.01); + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr option = std::make_shared(); - option->maximum_correspondence_distance_ = 0.05; - option->iteration_number_ = 100; - option->maximum_tuple_count_ = 500; + option->maximum_correspondence_distance_ = maxCorrespondenceDistance; + option->iteration_number_ = iterationNumber; + option->maximum_tuple_count_ = maxTupleCount; auto result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(*sourceO3D, *targetO3D, @@ -60,13 +59,13 @@ namespace diffCheck::registration std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(0.01); - targetO3D->VoxelDownSample(0.01); + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); std::shared_ptr option = std::make_shared(); - option->maximum_correspondence_distance_ = 0.05; - option->iteration_number_ = 100; - option->maximum_tuple_count_ = 500; + option->maximum_correspondence_distance_ = maxCorrespondenceDistance; + option->iteration_number_ = iterationNumber; + option->maximum_tuple_count_ = maxTupleCount; std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); @@ -95,8 +94,8 @@ namespace diffCheck::registration std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(0.01); - targetO3D->VoxelDownSample(0.01); + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); @@ -126,8 +125,8 @@ namespace diffCheck::registration std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(0.01); - targetO3D->VoxelDownSample(0.01); + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); diff --git a/src/diffCheck/registration/globalregistration.hh b/src/diffCheck/registration/globalregistration.hh index f620b704..46813311 100644 --- a/src/diffCheck/registration/globalregistration.hh +++ b/src/diffCheck/registration/globalregistration.hh @@ -9,32 +9,38 @@ namespace diffCheck::registration class GlobalRegistration { public: - + + /** + * @brief Compute the "point to point" distance between two point clouds. + * For every point in the source point cloud it looks in the KDTree of the target point cloud and finds the closest point. + * It returns a vector of distances, one for each point in the source point cloud. + * @param source The source diffCheck point cloud + * @param target The target diffCheck point cloud + * + * @see https://github.com/isl-org/Open3D/blob/main/cpp/open3d/geometry/PointCloud.cpp + */ static std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); /** - Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html - Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). - point features historigrams generalize this concept by computing point features in a local neighborhood of a point, stored as higher-dimentional historigrams. - - For example, for a given point, you take all the neighboring points within a given radius, and create a complete graph on those vertices. - then for each edge of the graph you compute features that are then stored in a historigram of the original center point from which the sphere and the graph where built. - https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation proposes a simple example of such a historigram. - - PCL's documentation refers to this 2009 TUM PhD thesis (but largely outside the scope of our work): https://mediatum.ub.tum.de/doc/800632/941254.pdf - - Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). - - @param source the source point cloud - @param target the target point cloud - @param voxelSize the size of the voxels used to downsample the point clouds - @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures - @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - @param maxCorrespondenceDistance the maximum distance between correspondences. - @param iterationNumber the number of iterations to run the RanSaC registration algorithm - @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace + * @brief Fast Global Registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * + * Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). + * point features historigrams generalize this concept by computing point features in a local neighborhood of a point, stored as higher-dimentional historigrams. + * + * Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + * @param source the source diffCheck point cloud + * @param target the target diffCheck point cloud + * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise. + * @param maxNeighborKDTreeSearch 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. + * @param maxCorrespondenceDistance the maximum distance between correspondences. As parameter of the FastGlobalRegistrationOption options + * @param iterationNumber 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 + * @param maxTupleCount 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 + * + * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation for more information on PFH (from PCL, not Open3D) + * @see https://mediatum.ub.tum.de/doc/800632/941254.pdf for in-depth documentation on the theory */ static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target, @@ -46,17 +52,17 @@ class GlobalRegistration int maxTupleCount = 500); /** - Little information on this registration method compared to the previous one. - If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them. - https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html - - @param source the source point cloud - @param target the target point cloud - @param voxelSize the size of the voxels used to downsample the point clouds - @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures - @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - @param iterationNumber the number of iterations to run the RanSaC registration algorithm - @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace + * @brief Fast Global Registration based on Correspondence using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * Little information on this registration method compared to the previous one. + * If understood correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them, instead of using all the features. + * https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html + * @param source the source diffCheck point cloud + * @param target the target diffCheck point cloud + * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + * @param iterationNumber the number of iterations to run the RanSaC registration algorithm + * @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace */ static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target, @@ -67,21 +73,20 @@ class GlobalRegistration int iterationNumber = 100, int maxTupleCount = 500); /** - Ransac registration based on correspondence: - Correspondances are computed between the source and target point clouds. - Then, a transformation is computed that minimizes the error between the correspondances. - If the error is above a certain threshold, the transformation is discarded and a new one is computed. + * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * Correspondances are computed between the source and target point clouds. + * Then, a transformation is computed that minimizes the error between the correspondances. + * If the error is above a certain threshold, the transformation is discarded and a new one is computed. - In practice, Open3D gives little information about the feature correspondence, compared to the FGR methods - - @param source the source point cloud - @param target the target point cloud - @param voxelSize the size of the voxels used to downsample the point clouds - @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures - @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - @param maxCorrespondenceDistance the maximum distance between correspondences. - @param correspondenceSetSize the number of correspondences to consider in the Ransac algorithm + * In practice, Open3D gives little information about the feature correspondence, compared to the FGR methods + * @param source the source diffCheck point cloud + * @param target the target diffCheck point cloud + * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + * @param maxCorrespondenceDistance the maximum distance between correspondences. + * @param correspondenceSetSize the number of correspondences to consider in the Ransac algorithm */ static open3d::pipelines::registration::RegistrationResult O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target, @@ -91,15 +96,14 @@ class GlobalRegistration double maxCorrespondenceDistance = 0.05, int correspondenceSetSize = 200); /** - Ransac registration based on Feature Matching - https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC - - @param source the source point cloud - @param target the target point cloud - @param voxelSize the size of the voxels used to downsample the point clouds - @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures - @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - @param maxCorrespondenceDistance the maximum distance between correspondences. + * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC + * @param source the source diffCheck point cloud + * @param target the target diffCheck point cloud + * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + * @param maxCorrespondenceDistance the maximum distance between correspondences. */ static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target, From fcffcb4da850b1359a28f5cbf7cb81ff647a17b4 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 23:34:02 +0200 Subject: [PATCH 052/141] WIP-FIX: improvements on documentation and missing doxygen tags --- .../registration/globalregistration.hh | 33 ++++++++++++------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/src/diffCheck/registration/globalregistration.hh b/src/diffCheck/registration/globalregistration.hh index 46813311..cf598764 100644 --- a/src/diffCheck/registration/globalregistration.hh +++ b/src/diffCheck/registration/globalregistration.hh @@ -11,7 +11,8 @@ class GlobalRegistration public: /** - * @brief Compute the "point to point" distance between two point clouds. + * @brief Compute the "point to point" distance between two point clouds. + * * For every point in the source point cloud it looks in the KDTree of the target point cloud and finds the closest point. * It returns a vector of distances, one for each point in the source point cloud. * @param source The source diffCheck point cloud @@ -29,7 +30,8 @@ class GlobalRegistration * Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). * point features historigrams generalize this concept by computing point features in a local neighborhood of a point, stored as higher-dimentional historigrams. * - * Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + * * @param source the source diffCheck point cloud * @param target the target diffCheck point cloud * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). @@ -53,16 +55,21 @@ class GlobalRegistration /** * @brief Fast Global Registration based on Correspondence using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds - * Little information on this registration method compared to the previous one. - * If understood correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them, instead of using all the features. - * https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html + * + * Little information on this registration method compared to Fast Global Registration Feature Matching. + * If understood correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them, instead of using all the feature historigrams. + * + * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + * * @param source the source diffCheck point cloud * @param target the target diffCheck point cloud * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures * @param iterationNumber the number of iterations to run the RanSaC registration algorithm - * @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace + * @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace + * + * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html (from PCL, not Open3D) */ static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target, @@ -74,12 +81,12 @@ class GlobalRegistration int maxTupleCount = 500); /** * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds - * Correspondances are computed between the source and target point clouds. + * Correspondances are computed between the source and target point clouds FPFH hyperspaces. * Then, a transformation is computed that minimizes the error between the correspondances. * If the error is above a certain threshold, the transformation is discarded and a new one is computed. - - * In practice, Open3D gives little information about the feature correspondence, compared to the FGR methods - + * + * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + * * @param source the source diffCheck point cloud * @param target the target diffCheck point cloud * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). @@ -97,13 +104,17 @@ class GlobalRegistration int correspondenceSetSize = 200); /** * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds - * https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC + * + * If understood correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them, instead of using all the feature historigrams. + * * @param source the source diffCheck point cloud * @param target the target diffCheck point cloud * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures * @param maxCorrespondenceDistance the maximum distance between correspondences. + * + * @see https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC (from PCL, not Open3D) */ static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target, From f32b8409206feea7ba6d363c8501cf5c4bc74443 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Tue, 16 Apr 2024 09:45:52 +0200 Subject: [PATCH 053/141] ADD: extra info and corrections on how to develop --- CONTRIBUTING.md | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 7156046b..6121378f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -88,20 +88,32 @@ That's it you are now a contributor to the diffCheck! We raccomand to not downlo ## GHPy: B) development/debug -### Code structure +### B.1) Code structure For DiffCheck there are 2 main folders in the repository: * `src/gh/diffCheck/components` here you can add new components or modify existing ones (for more info on how to create one we point you to [this documentation](https://github.com/compas-dev/compas-actions.ghpython_components)). Here we call the * `src/gh/diffCheck/diffCheck` this is our package where the core functionalities are implemented. -### IDE +### B.2) Developing component's content +The idea is to start by developing the content of the component in the file `src/gh/diffCheck/diffCgeck_app.py`. This would be a simple script that contains the logic of the component. Once the script `diffCheck_app.py` is working correctly, you can move the code to the component file in the `src/gh/diffCheck/components` folder. This is because the component file is the one that will be componentized and distributed via yak. + We reccomand to use `VSCode` as IDE for developing the components. This is because it has a good integration with the `Grasshopper` environment and it is easy to debug the components. To set up the IDE follow these steps: 1. Install the `ScriptSync` extension for `VSCode`. 2. Install the `ScriptSync` from the yak manager in Rhino. -3. Open the `code.py` from the `src/gh/diffCheck/components` folder you are working on in `VSCode`, and set its path to the ScriptSync ghcomponent. +3. Open the `diffCheckApp.py` from the `src/gh/diffCheck/components` folder you are working on in `VSCode`, and set its path to the ScriptSync ghcomponent. 4. If you modify the code in `VSCode`, the changes will be reflected in the Grasshopper component as soon as you save in `VSCode` again the `code.py`. +5. Once your code is working, prepare the code and componentize it. If you want to use the GHEditor it's ok but everytime you modify the pakcage or the component's code, after any modifications you need to restart the Python interpreter from the ScriptEditor (`Tools > Reload Python3 (CPython) Engine`) and recompute the solution in Grasshopper. +### B.3) Componentize the code +Prepare your component as explained here. You can componentize it locally and test it in Grasshopper. Here's how to componentize: +```terminal +python f:\diffCheck\src\gh\util\componentizer_cpy.py --ghio "C:\Users\andre\.nuget\packages\grasshopper\8.2.23346.13001\lib\net48\" .\src\gh\components\ .\build\gh +``` +> Note that you need to find the path to your GHIO folder. This is the folder where the `Grasshopper.dll` is located. E.g. You can find it in the `nuget` folder in the Rhino installation directory. + +Once you are sure that the component is working correctly, you can push the changes to the repository. + ## GHPy: C) Release The release will be made via CI from main. As a contributor you don't need to worry about this. The plug-in is componentized, pushed to yak/PyPI and the user can download the latest version from yak. From fc2747698cc9e13aa318c4574a41ea74bf3fef07 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Tue, 16 Apr 2024 19:02:22 +0200 Subject: [PATCH 054/141] WIP: EvaluateRegistration static method added and default parameters of Ransac methods now exposed --- .../registration/globalregistration.cc | 78 ++++++++++++--- .../registration/globalregistration.hh | 51 +++++++--- src/diffCheckApp.cc | 94 +++++-------------- 3 files changed, 130 insertions(+), 93 deletions(-) diff --git a/src/diffCheck/registration/globalregistration.cc b/src/diffCheck/registration/globalregistration.cc index 5d641a73..faa9e13f 100644 --- a/src/diffCheck/registration/globalregistration.cc +++ b/src/diffCheck/registration/globalregistration.cc @@ -14,8 +14,26 @@ namespace diffCheck::registration return distances; } + std::vector GlobalRegistration::EvaluateRegistrations(std::shared_ptr source, + std::shared_ptr target, + std::vector> transforms) + { + std::vector errors; + for(int i = 0; i < transforms.size(); i++) + { + std::shared_ptr o3DPointCloud = source->Cvt2O3DPointCloud(); + std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(o3DPointCloud->Transform(transforms[i])); + std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); + dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); + std::vector registrationErrors = ComputeP2PDistance(dfPointCloudPtrAfterTrans, target); + errors.push_back(std::accumulate(registrationErrors.begin(), registrationErrors.end(), 0.0) / registrationErrors.size()); + } + return errors; + }; + open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target, + bool voxelise, double voxelSize, double radiusKDTreeSearch, int maxNeighborKDTreeSearch, @@ -26,8 +44,11 @@ namespace diffCheck::registration std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); + if (voxelise) + { + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); + } std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); @@ -49,6 +70,7 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target, + bool voxelise, double voxelSize, double radiusKDTreeSearch, int maxNeighborKDTreeSearch, @@ -59,8 +81,11 @@ namespace diffCheck::registration std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); + if (voxelise) + { + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); + } std::shared_ptr option = std::make_shared(); option->maximum_correspondence_distance_ = maxCorrespondenceDistance; @@ -85,23 +110,33 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target, + bool voxelise, double voxelSize, double radiusKDTreeSearch, int maxNeighborKDTreeSearch, double maxCorrespondenceDistance, - int correspondenceSetSize) + int ransacN, + double correspondenceCheckerDistance , + int ransacMaxIteration, + double ransacConfidenceThreshold) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); + if (voxelise) + { + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); + } std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + std::vector> correspondanceChecker; + open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance); + correspondanceChecker.push_back(checkerOnDistance); open3d::pipelines::registration::CorrespondenceSet correspondanceset; correspondanceset = open3d::pipelines::registration::CorrespondencesFromFeatures(*sourceFPFHFeatures, *targetFPFHFeatures); @@ -111,33 +146,52 @@ namespace diffCheck::registration correspondanceset, maxCorrespondenceDistance, open3d::pipelines::registration::TransformationEstimationPointToPoint(), - correspondenceSetSize); + ransacN, + correspondanceChecker, + open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); return result; } open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target, + bool voxelise, double voxelSize, double radiusKDTreeSearch, int maxNeighborKDTreeSearch, - double maxCorrespondenceDistance) + double maxCorrespondenceDistance, + open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation, + int ransacN, + double correspondenceCheckerDistance , + int ransacMaxIteration, + double ransacConfidenceThreshold) { std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); + if (voxelise) + { + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); + } std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + std::vector> correspondanceChecker; + open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance); + correspondanceChecker.push_back(checkerOnDistance); + auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D, *targetO3D, *sourceFPFHFeatures, *targetFPFHFeatures, false, - maxCorrespondenceDistance); + maxCorrespondenceDistance, + transformationEstimation, + ransacN, + correspondanceChecker, + open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); return result; } diff --git a/src/diffCheck/registration/globalregistration.hh b/src/diffCheck/registration/globalregistration.hh index cf598764..11fe8877 100644 --- a/src/diffCheck/registration/globalregistration.hh +++ b/src/diffCheck/registration/globalregistration.hh @@ -2,6 +2,7 @@ #include "diffCheck.hh" #include +#include namespace diffCheck::registration { @@ -15,6 +16,7 @@ class GlobalRegistration * * For every point in the source point cloud it looks in the KDTree of the target point cloud and finds the closest point. * It returns a vector of distances, one for each point in the source point cloud. + * * @param source The source diffCheck point cloud * @param target The target diffCheck point cloud * @@ -22,9 +24,19 @@ class GlobalRegistration */ static std::vector ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target); - /** - + * @brief Evaluate the registration of a source point cloud to a target point cloud by applying a transformation matrix to the source point cloud and evaluate the error between the transformed source point cloud and the target point cloud. + * + * @param source The source diffCheck point cloud + * @param target The target diffCheck point cloud + * @param transform The vector of transformation matrix to apply to the source point cloud. + */ + + static std::vector EvaluateRegistrations(std::shared_ptr source, + std::shared_ptr target, + std::vector> transforms); + + /** * @brief Fast Global Registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds * * Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). @@ -37,15 +49,17 @@ class GlobalRegistration * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise. * @param maxNeighborKDTreeSearch 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. - * @param maxCorrespondenceDistance the maximum distance between correspondences. As parameter of the FastGlobalRegistrationOption options + * @param maxCorrespondenceDistance the maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones. * @param iterationNumber 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 * @param maxTupleCount 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 * + * @see https://link.springer.com/content/pdf/10.1007/978-3-319-46475-6_47.pdf for the original article on Fast Global Registration * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation for more information on PFH (from PCL, not Open3D) * @see https://mediatum.ub.tum.de/doc/800632/941254.pdf for in-depth documentation on the theory */ static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target, + bool voxelize = true, double voxelSize = 0.01, double radiusKDTreeSearch = 3, int maxNeighborKDTreeSearch = 50, @@ -54,7 +68,7 @@ class GlobalRegistration int maxTupleCount = 500); /** - * @brief Fast Global Registration based on Correspondence using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * @brief Fast Global Registration based on Correspondence using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds. Initially developped in open3d to allow other features then FPFH to be used. * * Little information on this registration method compared to Fast Global Registration Feature Matching. * If understood correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them, instead of using all the feature historigrams. @@ -66,13 +80,14 @@ class GlobalRegistration * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - * @param iterationNumber the number of iterations to run the RanSaC registration algorithm + * @param iterationNumber the number of iterations to run the Fast Global Registration algorithm. * @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace * * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html (from PCL, not Open3D) */ static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target, + bool voxelize = true, double voxelSize = 0.01, double radiusKDTreeSearch = 3, int maxNeighborKDTreeSearch = 50, @@ -80,7 +95,8 @@ class GlobalRegistration int iterationNumber = 100, int maxTupleCount = 500); /** - * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds. + * * Correspondances are computed between the source and target point clouds FPFH hyperspaces. * Then, a transformation is computed that minimizes the error between the correspondances. * If the error is above a certain threshold, the transformation is discarded and a new one is computed. @@ -92,36 +108,49 @@ class GlobalRegistration * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxCorrespondenceDistance the maximum distance between correspondences. + * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. * @param correspondenceSetSize the number of correspondences to consider in the Ransac algorithm */ static open3d::pipelines::registration::RegistrationResult O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target, + bool voxelize = true, double voxelSize = 0.01, double radiusKDTreeSearch = 3, int maxNeighborKDTreeSearch = 50, double maxCorrespondenceDistance = 0.05, - int correspondenceSetSize = 200); + int ransacN = 3, + double correspondenceCheckerDistance = 0.05, + int ransacMaxIteration = 1000, + double ransacConfidenceThreshold = 0.999); /** * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds * - * If understood correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them, instead of using all the feature historigrams. + * This method picks random points in the source point cloud, gets the FPFH of those points and find the closest points in the FPFH space of the target point cloud. If the transformation the two sets of point yields a low enough error, it is kept. * * @param source the source diffCheck point cloud * @param target the target diffCheck point cloud * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxCorrespondenceDistance the maximum distance between correspondences. + * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. + * @param transformationEstimation the transformation estimation method to use. By default, it uses a point to point transformation estimation. + * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute. + * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. * * @see https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC (from PCL, not Open3D) */ static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target, + bool voxelize = true, double voxelSize = 0.01, double radiusKDTreeSearch = 3, int maxNeighborKDTreeSearch = 50, - double maxCorrespondenceDistance = 0.05); + double maxCorrespondenceDistance = 0.05, + open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = open3d::pipelines::registration::TransformationEstimationPointToPoint(false), + int ransacN = 3, + double correspondenceCheckerDistance = 0.05, + int ransacMaxIteration = 1000, + double ransacConfidenceThreshold = 0.999); }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index e5275442..f4161c76 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -14,10 +14,8 @@ int main() { std::shared_ptr dfPointCloudPtr = std::make_shared(); - std::shared_ptr dfPointCloudPtrAfterTrans_1 = std::make_shared(); - std::shared_ptr dfPointCloudPtrAfterTrans_2 = std::make_shared(); - std::shared_ptr dfPointCloudPtrAfterTrans_3 = std::make_shared(); - std::shared_ptr dfPointCloudPtrAfterTrans_4 = std::make_shared(); + std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); + std::shared_ptr dfPointCloudPtrGroundTruthNoNormals = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); @@ -31,23 +29,16 @@ int main() // add noise to dfPointCloudPtr for (int i = 0; i < dfPointCloudPtr->Points.size(); i++) { - dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01 ; + dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.1 ; } - std::vector timesFGRFeatureMatching; - std::vector timesFGRCorrespondance; - std::vector timesRansacCorrespondance; - std::vector timesRansacFeatureMatching; - - std::vector errorsFGRFeatureMatching; - std::vector errorsFGRCorrespondance; - std::vector errorsRansacCorrespondance; - std::vector errorsRansacFeatureMatching; int iterations = 50; // populate the mesh with points and store it in dfPointCloudPtrGroundTruth - dfPointCloudPtrGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(100000)); - + dfPointCloudPtrGroundTruthNoNormals->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + std::shared_ptr pcd = dfPointCloudPtrGroundTruthNoNormals->Cvt2O3DPointCloud(); + pcd->EstimateNormals(); + dfPointCloudPtrGroundTruth->Cvt2DFPointCloud(pcd); std::vector transformations; for (int i = 0; i < iterations; i++) { @@ -66,78 +57,41 @@ int iterations = 50; std::shared_ptr o3DPointCloud = dfPointCloudPtr->Cvt2O3DPointCloud(); std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(o3DPointCloud->Transform(transformations[i])); - dfPointCloudPtrAfterTrans_1 = std::make_shared(); - dfPointCloudPtrAfterTrans_2 = std::make_shared(); - dfPointCloudPtrAfterTrans_3 = std::make_shared(); - dfPointCloudPtrAfterTrans_4 = std::make_shared(); + dfPointCloudPtrAfterTrans = std::make_shared(); + - dfPointCloudPtrAfterTrans_1->Cvt2DFPointCloud(o3DPointCloudAfterTrans); - dfPointCloudPtrAfterTrans_2->Cvt2DFPointCloud(o3DPointCloudAfterTrans); - dfPointCloudPtrAfterTrans_3->Cvt2DFPointCloud(o3DPointCloudAfterTrans); - dfPointCloudPtrAfterTrans_4->Cvt2DFPointCloud(o3DPointCloudAfterTrans); + dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); + std::vector> registrationResults; // Testing the Fast Global Registration on Feature Matching method std::shared_ptr dfPointCloudPtrAfterReg_1 = std::make_shared(); - clock_t start_1 = clock(); - auto result_1 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_1, dfPointCloudPtr); - double _intermediate_time_1 = (clock() - start_1) / (double) CLOCKS_PER_SEC; - timesFGRFeatureMatching.push_back(_intermediate_time_1); + auto result_1 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); Eigen::Matrix transformation = result_1.transformation_; - std::shared_ptr o3DPointCloudPtrAfterReg_1 = std::make_shared(dfPointCloudPtrAfterTrans_1->Cvt2O3DPointCloud()->Transform(transformation)); - dfPointCloudPtrAfterReg_1->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_1); - std::vector errors_1 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_1, dfPointCloudPtrGroundTruth); - errorsFGRFeatureMatching.push_back(std::accumulate(errors_1.begin(), errors_1.end(), 0.0) / errors_1.size()); - + registrationResults.push_back(transformation); + // Testing the Fast Global Registration on Correspondance method std::shared_ptr dfPointCloudPtrAfterReg_2 = std::make_shared(); - clock_t start_2 = clock(); - auto result_2 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_2, dfPointCloudPtr); - double _intermediate_time_2 = (clock() - start_2) / (double) CLOCKS_PER_SEC; - timesFGRCorrespondance.push_back(_intermediate_time_2); + auto result_2 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); Eigen::Matrix transformation_2 = result_2.transformation_; - std::shared_ptr o3DPointCloudPtrAfterReg_2 = std::make_shared(dfPointCloudPtrAfterTrans_2->Cvt2O3DPointCloud()->Transform(transformation_2)); - dfPointCloudPtrAfterReg_2->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_2); - std::vector errors_2 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_2, dfPointCloudPtrGroundTruth); - errorsFGRCorrespondance.push_back(std::accumulate(errors_2.begin(), errors_2.end(), 0.0) / errors_2.size()); - + registrationResults.push_back(transformation_2); + // Testing the Ransac registration based on correspondance method std::shared_ptr dfPointCloudPtrAfterReg_3 = std::make_shared(); - clock_t start_3 = clock(); - auto result_3 = diffCheck::registration::GlobalRegistration::O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans_3, dfPointCloudPtr); - double _intermediate_time_3 = (clock() - start_3) / (double) CLOCKS_PER_SEC; - timesRansacCorrespondance.push_back(_intermediate_time_3); + auto result_3 = diffCheck::registration::GlobalRegistration::O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); Eigen::Matrix transformation_3 = result_3.transformation_; - std::shared_ptr o3DPointCloudPtrAfterReg_3 = std::make_shared(dfPointCloudPtrAfterTrans_3->Cvt2O3DPointCloud()->Transform(transformation_3)); - dfPointCloudPtrAfterReg_3->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_3); - std::vector errors_3 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_3, dfPointCloudPtrGroundTruth); - errorsRansacCorrespondance.push_back(std::accumulate(errors_3.begin(), errors_3.end(), 0.0) / errors_3.size()); + registrationResults.push_back(transformation_3); // Testing the Ransac registration based on Feature Matching method std::shared_ptr dfPointCloudPtrAfterReg_4 = std::make_shared(); - clock_t start_4 = clock(); - auto result_4 = diffCheck::registration::GlobalRegistration::O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans_4, dfPointCloudPtr); - double _intermediate_time_4 = (clock() - start_4) / (double) CLOCKS_PER_SEC; - timesRansacFeatureMatching.push_back(_intermediate_time_4); + auto result_4 = diffCheck::registration::GlobalRegistration::O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); Eigen::Matrix transformation_4 = result_4.transformation_; - std::shared_ptr o3DPointCloudPtrAfterReg_4 = std::make_shared(dfPointCloudPtrAfterTrans_4->Cvt2O3DPointCloud()->Transform(transformation_4)); - dfPointCloudPtrAfterReg_4->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_4); - std::vector errors_4 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_4, dfPointCloudPtrGroundTruth); - errorsRansacFeatureMatching.push_back(std::accumulate(errors_4.begin(), errors_4.end(), 0.0) / errors_4.size()); + registrationResults.push_back(transformation_4); std::cout<<"Iteration: "< errors = diffCheck::registration::GlobalRegistration::EvaluateRegistrations(dfPointCloudPtrAfterTrans, dfPointCloudPtr, registrationResults); + std::cout<<"Errors: FGRCorrespondence "< Date: Wed, 17 Apr 2024 10:29:18 +0200 Subject: [PATCH 055/141] FIX: Delete diffCheckErrors.log --- diffCheckErrors.log | 4 ---- 1 file changed, 4 deletions(-) delete mode 100644 diffCheckErrors.log diff --git a/diffCheckErrors.log b/diffCheckErrors.log deleted file mode 100644 index 092b5e99..00000000 --- a/diffCheckErrors.log +++ /dev/null @@ -1,4 +0,0 @@ -arguments: loguru -Current dir: F:\diffCheck -File verbosity level: -2 -date time ( uptime ) [ thread name/id ] file:line v| From 1c8bba6310480e8d785b5c462e3f93f3edf98538 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 17 Apr 2024 10:29:34 +0200 Subject: [PATCH 056/141] FIX: Delete diffCheckEvery.log --- diffCheckEvery.log | 6 ------ 1 file changed, 6 deletions(-) delete mode 100644 diffCheckEvery.log diff --git a/diffCheckEvery.log b/diffCheckEvery.log deleted file mode 100644 index 20fc75ab..00000000 --- a/diffCheckEvery.log +++ /dev/null @@ -1,6 +0,0 @@ -arguments: loguru -Current dir: F:\diffCheck -File verbosity level: 9 -date time ( uptime ) [ thread name/id ] file:line v| -2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckEvery.log', mode: 'w', verbosity: 9 -2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckErrors.log', mode: 'w', verbosity: -2 From a928f8915f4b0dd8b50791c12259e0f774ceebb9 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 17 Apr 2024 15:42:01 +0200 Subject: [PATCH 057/141] FIX: catching non-planar faces --- deps/eigen | 2 +- .../diffCheck/diffCheck/df_joint_detector.py | 14 +- .../{diffCheck => }/diffCheck_app.py | 8 +- src/gh/tester.ghx | 1230 +++++++++++++---- 4 files changed, 997 insertions(+), 257 deletions(-) rename src/gh/diffCheck/{diffCheck => }/diffCheck_app.py (86%) diff --git a/deps/eigen b/deps/eigen index 9099c5ea..b5feca5d 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 9099c5eac756ff44cf901b4cd31e08ad2efda46b +Subproject commit b5feca5d03185d99fe011bcade16a181f567fca0 diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index 7546819e..cd3553ec 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -8,6 +8,8 @@ import diffCheck.df_util import diffCheck.df_transformations +from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML + @dataclass class JointDetector: @@ -153,10 +155,11 @@ def run(self) : if f_b is not None: if f_b.IsSolid: self._cuts.append(f_b) - for f_b in non_flat_faces_b: - if f_b is not None: - if f_b.IsSolid: - self._holes.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 @@ -195,4 +198,7 @@ def run(self) : 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 \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py similarity index 86% rename from src/gh/diffCheck/diffCheck/diffCheck_app.py rename to src/gh/diffCheck/diffCheck_app.py index 51d218ee..de99baf5 100644 --- a/src/gh/diffCheck/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck_app.py @@ -9,11 +9,8 @@ import diffCheck import diffCheck.df_geometries -import sys -import importlib -for key in list(sys.modules.keys()): - if "diffCheck" in key: - importlib.reload(sys.modules[key]) +print(diffCheck.__version__) + if __name__ == "__main__": """ @@ -22,6 +19,7 @@ :param i_export_dir: directory to export the xml :param i_dump: whether to dump the xml """ + # data_faces = diffCheck.df_joint_detector.JointDetector(i_breps[0]).run() # beams beams = [] for brep in i_breps: diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index e0bac28c..6ccbdaa3 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 249 - -620 + 284 + -384 - 0.7830095 + 1.7647059 @@ -68,7 +68,9 @@ - + + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py F:\diffCheck\src\gh\diffCheck\diffCheck\diffCheck_app.py F:\diffCheck\src\gh\diffCheck\diffCheck\test.py @@ -100,9 +102,9 @@ - 37 + 44 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -111,7 +113,7 @@ - + true 2 @@ -119,6 +121,7 @@ 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 dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 + true true false true @@ -161,13 +164,14 @@ - + true Connect a button to open a file dialog to select a cpython file to run. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= 083c2fe3-a45a-43c1-8f85-ce20a4a69a99 + true btn btn true @@ -196,13 +200,14 @@ - + true rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== e0ef2066-70a4-441f-906b-8a4afddb0692 + true i_export_dir i_export_dir true @@ -231,7 +236,7 @@ - + 1 true Converts to collection of Breps (Boundary REPresentations) @@ -239,6 +244,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= ae8c9c0d-8d6a-4a8c-812a-110846a2031c + true i_breps i_breps true @@ -267,13 +273,14 @@ - + true rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== d9632669-508e-4a03-b9bc-a5d740ef546f + true i_assembly_name i_assembly_name true @@ -302,13 +309,14 @@ - + true Converts to collection of boolean values iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC 1e3c2c63-ede9-4faf-9790-a3d1b9350ba3 + true i_dump i_dump true @@ -337,13 +345,14 @@ - + false The redirected standard output of the component scriptsync. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 + true stdout stdout false @@ -371,13 +380,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== a849584f-8d8a-4547-a1a4-36be0bf3ac37 + true o_xml o_xml false @@ -405,13 +415,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 178951a0-3c74-4810-aef0-87cc45b0502c + true o_joints o_joints false @@ -439,13 +450,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 76758d37-2a1d-412d-b85b-149ecda8a020 + true o_sides o_sides false @@ -500,11 +512,12 @@ - + Button object with two values False True 5f8bfbf4-70d5-46ba-90fa-f3804e9a9032 + true Button false @@ -532,10 +545,11 @@ - + Contains a collection of Breps (Boundary REPresentations) true 0f309845-29e6-43ae-b255-cdb5c2d13da9 + true Brep Brep false @@ -594,7 +608,7 @@ false 1 - 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 + 99e48b23-64d9-4e2f-859d-62348fa491ae 1 Double click to edit panel content… @@ -602,8 +616,8 @@ - 418 - -193 + 731 + 203 494 251 @@ -611,8 +625,8 @@ 0 0 - 418.41595 - -192.65623 + 731.9958 + 203.22206 @@ -704,14 +718,14 @@ - 397 - 180 + 473 + 320 48 44 - 431 - 202 + 507 + 342 @@ -723,21 +737,21 @@ Geometry G false - 178951a0-3c74-4810-aef0-87cc45b0502c + d9399b7b-ece0-4d60-ba8e-0bb8c0bdf01a 1 - 399 - 182 + 475 + 322 17 20 - 409 - 192 + 485 + 332 @@ -757,14 +771,14 @@ - 399 - 202 + 475 + 342 17 20 - 409 - 212 + 485 + 352 @@ -823,14 +837,14 @@ - 398 - 227 + 473 + 382 48 44 - 432 - 249 + 507 + 404 @@ -842,21 +856,21 @@ Geometry G false - 76758d37-2a1d-412d-b85b-149ecda8a020 + 8051ced1-c685-4aac-b373-3da1f25a7345 1 - 400 - 229 + 475 + 384 17 20 - 410 - 239 + 485 + 394 @@ -876,14 +890,14 @@ - 400 - 249 + 475 + 404 17 20 - 410 - 259 + 485 + 414 @@ -945,14 +959,14 @@ - 276 - 220 + 369 + 343 88 20 - 276.14133 - 220.3679 + 369.056 + 343.67847 @@ -967,11 +981,12 @@ - + Button object with two values False True 254a4a2f-d415-488e-9851-4a763f1ba58f + true Button dump! false @@ -999,11 +1014,12 @@ - + Contains a collection of file paths false All files|*.* 77c76654-6be3-4843-b564-afe44705740d + true File Path Path false @@ -1056,9 +1072,10 @@ - + A panel for custom notes and text values 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 + true Panel false @@ -1123,14 +1140,14 @@ - 273 - 249 + 369 + 405 88 20 - 273.53714 - 249.41264 + 369.17673 + 405.9497 @@ -1315,13 +1332,13 @@ 159 - 656 + 848 50 24 184.61072 - 668.0817 + 860.9274 @@ -1397,13 +1414,13 @@ 159 - 629 + 822 50 24 184.87698 - 641.2265 + 834.0722 @@ -1455,7 +1472,7 @@ 106 - 569 + 761 102 22 @@ -1488,7 +1505,7 @@ 111 - 602 + 795 102 20 @@ -1497,7 +1514,7 @@ 0 111.36775 - 602.9323 + 795.778 @@ -1539,13 +1556,13 @@ 602 - 647 + 839 48 44 636 - 669 + 861 @@ -1566,13 +1583,13 @@ 604 - 649 + 841 17 20 614 - 659 + 851 @@ -1594,13 +1611,13 @@ 604 - 669 + 861 17 20 614 - 679 + 871 @@ -1661,13 +1678,13 @@ 603 - 694 + 886 48 44 637 - 716 + 908 @@ -1688,13 +1705,13 @@ 605 - 696 + 888 17 20 615 - 706 + 898 @@ -1716,13 +1733,13 @@ 605 - 716 + 908 17 20 615 - 726 + 918 @@ -1786,13 +1803,13 @@ 478 - 670 + 863 88 20 478.32407 - 670.98126 + 863.82697 @@ -1824,13 +1841,13 @@ 480 - 718 + 911 88 20 480.05487 - 718.3294 + 911.1751 @@ -1846,7 +1863,7 @@ - + true 2 @@ -1854,6 +1871,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= 0bc1d704-d9a5-496a-8097-0e77a2179817 + true true false true @@ -1867,18 +1885,17 @@ - + 291 - 992 + 1184 171 84 398 - 1034 + 1226 - true @@ -1895,13 +1912,14 @@ - + true Press button to export xml iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= ff7bc6fc-cd70-4c56-8f79-fc4cbd06681c + true i_dump i_dump true @@ -1914,30 +1932,30 @@ - + 293 - 994 + 1186 90 20 339.5 - 1004 + 1196 - true - + true The name of the assembly to export. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC eac6f337-07dc-4148-804b-ee5f29e1c0f7 + true i_assembly_name i_assembly_name true @@ -1950,30 +1968,30 @@ - + 293 - 1014 + 1206 90 20 339.5 - 1024 + 1216 - true - + true The directors where to export the xml file. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 0341be27-157c-4fa0-8841-4876c4aa61b9 + true i_export_dir i_export_dir true @@ -1986,24 +2004,23 @@ - + 293 - 1034 + 1226 90 20 339.5 - 1044 + 1236 - true - + 1 true The breps of the structure. @@ -2011,6 +2028,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== f7f134be-ff73-4607-8432-4027726d7c9a + true i_breps i_breps true @@ -2023,30 +2041,30 @@ - + 293 - 1054 + 1246 90 20 339.5 - 1064 + 1256 - true - + false The string of xml to be exported. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 63fce5d6-5cca-4c37-978e-16ad72dccdf6 + true o_xml o_xml false @@ -2058,30 +2076,30 @@ - + 413 - 994 + 1186 47 26 436.5 - 1007.3333 + 1199.3334 - true - + false The breps of the faces belonging to joints. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC d876ac7a-afbf-4696-a6c0-6b8d5230d058 + true o_joints o_joints false @@ -2093,30 +2111,30 @@ - + 413 - 1020 + 1212 47 27 436.5 - 1034 + 1226 - true - + false The breps of the faces belonging to sides. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC cd81b022-0563-4d70-8ad2-86542a5f5a10 + true o_sides o_sides false @@ -2128,18 +2146,17 @@ - + 413 - 1047 + 1239 47 27 436.5 - 1060.6667 + 1252.6667 - true @@ -2172,10 +2189,11 @@ - + Contains a collection of Breps (Boundary REPresentations) true f6905f9e-831e-4c85-831f-4a85822df09c + true Brep Brep false @@ -2183,18 +2201,17 @@ - + 214 - 1053 + 1246 50 24 239.74905 - 1065.9746 + 1258.8203 - true @@ -2253,11 +2270,12 @@ - + Button object with two values False True 508c9c16-1d49-4404-84cc-7cc48c8f273b + true Button dump! false @@ -2265,14 +2283,13 @@ - + 161 - 993 + 1185 102 22 - true @@ -2286,11 +2303,12 @@ - + Contains a collection of file paths false All files|*.* 3f1b8093-20ad-4b03-90b2-110f234137fc + true File Path Path false @@ -2298,18 +2316,17 @@ - + 214 - 1033 + 1226 50 24 239.17398 - 1045.7389 + 1238.5846 - true @@ -2344,9 +2361,10 @@ - + A panel for custom notes and text values a170d6d1-471e-4c64-9806-444e47f21d66 + true Panel false @@ -2356,10 +2374,10 @@ - + 161 - 1016 + 1208 102 20 @@ -2368,9 +2386,8 @@ 0 161.45294 - 1016.0344 + 1208.8801 - true @@ -2397,35 +2414,36 @@ - + Allows for customized geometry previews true e82c0b60-8d4c-487a-8a2a-60ccdfb2c440 + true Custom Preview Preview - + 587 - 992 + 1184 48 44 621 - 1014 + 1206 - true - + Geometry to preview true f483e244-6e89-4839-a140-53b2307e5305 + true Geometry G false @@ -2434,26 +2452,26 @@ - + 589 - 994 + 1186 17 20 599 - 1004 + 1196 - true - + The material override 5eadcdca-b596-4817-b74a-daf84cb33bba + true Material M false @@ -2462,18 +2480,17 @@ - + 589 - 1014 + 1206 17 20 599 - 1024 + 1216 - true @@ -2519,35 +2536,36 @@ - + Allows for customized geometry previews true 1cf1d421-79da-445c-baea-160043841df5 + true Custom Preview Preview - + 588 - 1039 + 1231 48 44 622 - 1061 + 1253 - true - + Geometry to preview true f3c7f1be-a13f-418f-bdc3-968772d68045 + true Geometry G false @@ -2556,26 +2574,26 @@ - + 590 - 1041 + 1233 17 20 600 - 1051 + 1243 - true - + The material override 14b44143-7bb4-4e4b-a0c1-8aeb245e6588 + true Material M false @@ -2584,18 +2602,17 @@ - + 590 - 1061 + 1253 17 20 600 - 1071 + 1263 - true @@ -2641,9 +2658,10 @@ - + Colour (palette) swatch 1652822d-91b6-4619-a0f1-929bd813d353 + true Colour Swatch Swatch false @@ -2654,18 +2672,17 @@ - + 484 - 1016 + 1209 88 20 484.3444 - 1016.3483 + 1209.1941 - true @@ -2679,9 +2696,10 @@ - + Colour (palette) swatch c217b73e-3729-4db1-951f-b5914db0d7d8 + true Colour Swatch Swatch false @@ -2692,18 +2710,17 @@ - + 485 - 1063 + 1256 88 20 485.70688 - 1063.3931 + 1256.2388 - true @@ -2743,13 +2760,13 @@ 741 - 549 + 741 72 44 770 - 571 + 763 @@ -2786,13 +2803,13 @@ 743 - 551 + 743 12 20 750.5 - 561 + 753 @@ -2821,13 +2838,13 @@ 743 - 571 + 763 12 20 750.5 - 581 + 773 @@ -2848,13 +2865,13 @@ 785 - 551 + 743 26 20 798 - 561 + 753 @@ -2883,13 +2900,13 @@ 785 - 571 + 763 26 20 798 - 581 + 773 @@ -2938,8 +2955,8 @@ - 897 - 500 + 1063 + 752 613 192 @@ -2947,8 +2964,8 @@ 0 0 - 897.0558 - 500.78198 + 1063.0818 + 752.3753 @@ -2992,8 +3009,8 @@ - 513 - 511 + 679 + 763 484 241 @@ -3001,8 +3018,8 @@ 0 0 - 513.0737 - 511.42526 + 679.09973 + 763.01855 @@ -3031,7 +3048,7 @@ - + true true @@ -3039,6 +3056,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== 82cff84c-8203-4d2d-a1d0-814c858ec33d + true true true true @@ -3075,7 +3093,7 @@ - + 1 true Converts to collection of Breps (Boundary REPresentations) @@ -3083,6 +3101,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= 08532ae2-a7b8-4bcb-ba9f-c6a7a22fe36f + true i_breps i_breps true @@ -3111,9 +3130,10 @@ - + The execution information, as output and error streams e73efe6e-ad59-49eb-837e-2c03904e0016 + true out out false @@ -3137,13 +3157,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== f4b0de2e-fef0-4b9d-876f-55b17adececd + true a a false @@ -3223,13 +3244,13 @@ 269 - 587 + 779 171 84 376 - 629 + 821 @@ -3271,13 +3292,13 @@ 271 - 589 + 781 90 20 317.5 - 599 + 791 @@ -3307,13 +3328,13 @@ 271 - 609 + 801 90 20 317.5 - 619 + 811 @@ -3343,13 +3364,13 @@ 271 - 629 + 821 90 20 317.5 - 639 + 831 @@ -3380,13 +3401,13 @@ 271 - 649 + 841 90 20 317.5 - 659 + 851 @@ -3407,13 +3428,13 @@ 391 - 589 + 781 47 20 414.5 - 599 + 791 @@ -3442,13 +3463,13 @@ 391 - 609 + 801 47 20 414.5 - 619 + 811 @@ -3477,13 +3498,13 @@ 391 - 629 + 821 47 20 414.5 - 639 + 831 @@ -3512,13 +3533,13 @@ 391 - 649 + 841 47 20 414.5 - 659 + 851 @@ -3553,7 +3574,7 @@ - + true 2 @@ -3561,6 +3582,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= 180538b6-48a7-45a7-9f63-4236e4b1aade + true true false true @@ -3577,13 +3599,13 @@ 288 - 888 + 1080 171 84 395 - 930 + 1122 @@ -3601,13 +3623,14 @@ - + true Press button to export xml iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= ee32ac69-2980-466c-a27d-24c46e0f978d + true i_dump i_dump true @@ -3622,26 +3645,27 @@ 290 - 890 + 1082 90 20 336.5 - 900 + 1092 - + true The name of the assembly to export. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 7937e977-a894-475a-9126-ab9f2badf263 + true i_assembly_name i_assembly_name true @@ -3656,26 +3680,27 @@ 290 - 910 + 1102 90 20 336.5 - 920 + 1112 - + true The directors where to export the xml file. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 5b90a98b-2119-45b1-9acc-86618952952a + true i_export_dir i_export_dir true @@ -3690,20 +3715,20 @@ 290 - 930 + 1122 90 20 336.5 - 940 + 1132 - + 1 true The breps of the structure. @@ -3711,6 +3736,7 @@ iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== b2b35e86-d097-457c-8dd0-fa8f391f2d52 + true i_breps i_breps true @@ -3725,26 +3751,27 @@ 290 - 950 + 1142 90 20 336.5 - 960 + 1152 - + false The string of xml to be exported. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC dae952a3-80b5-46b4-83e6-d4a74502350d + true o_xml o_xml false @@ -3759,26 +3786,27 @@ 410 - 890 + 1082 47 26 433.5 - 903.3333 + 1095.3334 - + false The breps of the faces belonging to joints. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC f9949a62-8862-4f11-9b42-5d9d2d9760da + true o_joints o_joints false @@ -3793,26 +3821,27 @@ 410 - 916 + 1108 47 27 433.5 - 930 + 1122 - + false The breps of the faces belonging to sides. iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 5c203e94-0aef-400c-8aec-d20d76f0571e + true o_sides o_sides false @@ -3827,13 +3856,13 @@ 410 - 943 + 1135 47 27 433.5 - 956.6666 + 1148.6667 @@ -3860,6 +3889,713 @@ + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + ef4234f1-74d1-42d5-8449-ae68033cb1a1 + Button + + false + 0 + + + + + + 35 + 235 + 66 + 22 + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + 07b41f33-b1e8-491e-82ae-3da0f5326222 + Brep + Brep + false + 0 + + + + + + 61 + 342 + 50 + 24 + + + 86.79881 + 354.94077 + + + + + + 1 + + + + + 1 + {0} + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + d89a87be-095f-41ba-bcfa-14a27b69959f + Button + dump! + false + 0 + + + + + + 10 + 397 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 78f00f3a-c6ac-40ac-9725-ad949c6e7593 + File Path + Path + false + 0 + + + + + + 63 + 315 + 50 + 24 + + + 88.27081 + 327.20453 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + c4486e03-f65b-4cbb-aaea-81fdbdcd7cf0 + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 13 + 371 + 102 + 20 + + 0 + 0 + 0 + + 13.415691 + 371.5 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + f98c6a9b-86ca-429d-8692-dcc245c0e6e5 + Panel + + false + 0 + 0 + diffCheck + + + + + + -13 + 263 + 113 + 38 + + 0 + 0 + 0 + + -12.635988 + 263.5192 + + + + + + + 255;213;217;232 + + true + true + false + false + false + true + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + This allows to run the current active cpython file from vscode to grasshopper. + true + 2 + + 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 + + 08fe15ed-12b6-4c72-a8ba-350c0da17df3 + true + false + true + script-sync cpython + scsy-cpy + 1 + + false + false + false + + + + + + 154 + 261 + 179 + 124 + + + 269 + 323 + + + + + + 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 + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 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. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + f703fbba-ff07-4709-8112-cd955660e259 + btn + btn + true + 0 + true + ef4234f1-74d1-42d5-8449-ae68033cb1a1 + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 156 + 263 + 98 + 20 + + + 206.5 + 273 + + + + + + + + 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 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + 0484038e-7609-494e-abc2-e4c58b9763d1 + packages_2_reload + packages_2_reload + true + 1 + true + f98c6a9b-86ca-429d-8692-dcc245c0e6e5 + 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 + + + + + + 156 + 283 + 98 + 20 + + + 206.5 + 293 + + + + + + + + true + Converts to collection of text fragments + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + 23c12915-418c-45d4-8a9f-82667941634f + i_export_dir + i_export_dir + true + 0 + true + 78f00f3a-c6ac-40ac-9725-ad949c6e7593 + 1 + + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 156 + 303 + 98 + 20 + + + 206.5 + 313 + + + + + + + + 1 + true + A generic x input. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + 770c2c41-936b-4563-8085-69258fb43fe4 + i_breps + i_breps + true + 1 + true + 07b41f33-b1e8-491e-82ae-3da0f5326222 + 1 + A generic x input. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 156 + 323 + 98 + 20 + + + 206.5 + 333 + + + + + + + + true + Converts to collection of text fragments + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + + c87fd4ae-11b7-4647-804e-d9cf678a79b3 + i_assembly_name + i_assembly_name + true + 0 + true + c4486e03-f65b-4cbb-aaea-81fdbdcd7cf0 + 1 + + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 156 + 343 + 98 + 20 + + + 206.5 + 353 + + + + + + + + true + Converts to collection of boolean values + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + de47b8a3-cb7b-43e4-b958-28f86271d143 + i_dump + i_dump + true + 0 + true + d89a87be-095f-41ba-bcfa-14a27b69959f + 1 + + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 156 + 363 + 98 + 20 + + + 206.5 + 373 + + + + + + + + false + The redirected standard output of the component scriptsync. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 99e48b23-64d9-4e2f-859d-62348fa491ae + stdout + stdout + false + 0 + true + 0 + The redirected standard output of the component scriptsync. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 263 + 47 + 30 + + + 307.5 + 278 + + + + + + + + false + Generic example output of the component + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 58680e01-bd51-44b8-bac4-82d9b43f37b0 + o_xml + o_xml + false + 0 + true + 0 + Generic example output of the component + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 293 + 47 + 30 + + + 307.5 + 308 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + d9399b7b-ece0-4d60-ba8e-0bb8c0bdf01a + o_joints + o_joints + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 323 + 47 + 30 + + + 307.5 + 338 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 8051ced1-c685-4aac-b373-3da1f25a7345 + o_sides + o_sides + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 353 + 47 + 30 + + + 307.5 + 368 + + + + + + + + + + false + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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:
                                    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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            packages_2_reload: System.Collections.Generic.IList[str],
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name: str,
            i_dump: bool):
        """ 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(btn)

        # 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 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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* + + + + + + + + @@ -3867,7 +4603,7 @@ - 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 + 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 From c4a4a3ffcede6a8f484996b8ca684e256f27a7b9 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 17 Apr 2024 16:03:48 +0200 Subject: [PATCH 058/141] ADD: catch if there is a hole, it stops --- src/gh/diffCheck/diffCheck/df_joint_detector.py | 2 ++ src/gh/diffCheck/diffCheck_app.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py index cd3553ec..2a9f0e93 100644 --- a/src/gh/diffCheck/diffCheck/df_joint_detector.py +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -101,6 +101,8 @@ def run(self) : 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) diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py index de99baf5..a0f84437 100644 --- a/src/gh/diffCheck/diffCheck_app.py +++ b/src/gh/diffCheck/diffCheck_app.py @@ -19,7 +19,7 @@ :param i_export_dir: directory to export the xml :param i_dump: whether to dump the xml """ - # data_faces = diffCheck.df_joint_detector.JointDetector(i_breps[0]).run() + # o_joints = diffCheck.df_joint_detector.JointDetector(i_breps[0]).run() # beams beams = [] for brep in i_breps: From 95a810bdc529eafb4c01d2c61277c06edfcfae12 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 17 Apr 2024 16:13:27 +0200 Subject: [PATCH 059/141] FIX: got rid of loggers --- diffCheckErrors.log | 4 ---- diffCheckEvery.log | 6 ------ 2 files changed, 10 deletions(-) delete mode 100644 diffCheckErrors.log delete mode 100644 diffCheckEvery.log diff --git a/diffCheckErrors.log b/diffCheckErrors.log deleted file mode 100644 index 092b5e99..00000000 --- a/diffCheckErrors.log +++ /dev/null @@ -1,4 +0,0 @@ -arguments: loguru -Current dir: F:\diffCheck -File verbosity level: -2 -date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log deleted file mode 100644 index 65db11f5..00000000 --- a/diffCheckEvery.log +++ /dev/null @@ -1,6 +0,0 @@ -arguments: loguru -Current dir: F:\diffCheck -File verbosity level: 9 -date time ( uptime ) [ thread name/id ] file:line v| -2024-03-30 14:03:39.030 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckEvery.log', mode: 'w', verbosity: 9 -2024-03-30 14:03:39.031 ( 0.002s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckErrors.log', mode: 'w', verbosity: -2 From 2fd09dad51e182eb76fe0ee67482b2e75d920e7e Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Thu, 18 Apr 2024 11:00:30 +0200 Subject: [PATCH 060/141] ADD: proposal icons - pcdlike --- README.md | 2 +- assets/logo/logo_400_400.png | Bin 13147 -> 0 bytes assets/logo/logo_pixelized.xcf | Bin 0 -> 139049 bytes assets/logo/logo_pixelized_596_618.png | Bin 0 -> 30399 bytes assets/logo/logo_pixelized_64_64.png | Bin 0 -> 14941 bytes assets/logo/logo_pixelized_64_64.xcf | Bin 0 -> 9512 bytes assets/logo/logo_raw.png | Bin 0 -> 40084 bytes assets/logo/logo_text_600_643.png | Bin 32605 -> 0 bytes assets/logo/logomaker.xcf | Bin 125150 -> 0 bytes assets/logo/logomaker_justlogo.xcf | Bin 74299 -> 0 bytes assets/logo/logotests.3dm | Bin 798682 -> 581635 bytes assets/logo/logotests.3dmbak | Bin 0 -> 680797 bytes assets/logo/raw2.png | Bin 12709 -> 0 bytes deps/eigen | 2 +- .../diffCheck/diffCheck.egg-info/requires.txt | 1 + .../dist/diffCheck-0.0.9-py3-none-any.whl | Bin 0 -> 10222 bytes src/gh/diffCheck/dist/diffCheck-0.0.9.tar.gz | Bin 0 -> 8196 bytes 17 files changed, 3 insertions(+), 2 deletions(-) delete mode 100644 assets/logo/logo_400_400.png create mode 100644 assets/logo/logo_pixelized.xcf create mode 100644 assets/logo/logo_pixelized_596_618.png create mode 100644 assets/logo/logo_pixelized_64_64.png create mode 100644 assets/logo/logo_pixelized_64_64.xcf create mode 100644 assets/logo/logo_raw.png delete mode 100644 assets/logo/logo_text_600_643.png delete mode 100644 assets/logo/logomaker.xcf delete mode 100644 assets/logo/logomaker_justlogo.xcf create mode 100644 assets/logo/logotests.3dmbak delete mode 100644 assets/logo/raw2.png create mode 100644 src/gh/diffCheck/diffCheck.egg-info/requires.txt create mode 100644 src/gh/diffCheck/dist/diffCheck-0.0.9-py3-none-any.whl create mode 100644 src/gh/diffCheck/dist/diffCheck-0.0.9.tar.gz diff --git a/README.md b/README.md index 1e17f87e..9af8f81b 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@

- +

diff --git a/assets/logo/logo_400_400.png b/assets/logo/logo_400_400.png deleted file mode 100644 index 55410e5c2e2aaaa849170b82c808ec7cbb24619f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13147 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 LNqGeLXe$3d6S|-c literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_596_618.png b/assets/logo/logo_pixelized_596_618.png new file mode 100644 index 0000000000000000000000000000000000000000..5da32d426e85672b4a6ad33fe07aa31cbdc84cdc GIT binary patch literal 30399 zcmV(xK zaB^>EX>4U6ba`-PAZ2)IW&i+q+NHf|lI6Ivb@!j6ctapSw8H^G&`dMX@U<2gk=48_ zlig31m6cg>ct{ZNW^aeP<5>Uq|MedK^FRL++S%KYa&4uTa`I2=smH-z+WGx6_J6~f z_J8+3Ii2z6r~ml*QO3^)ksn?Bd3_(W^8FcpfBy4@-#^3PZ~1RGYV+rV`=1~5^!*vz zzi#yNpvw_Cgy-i*{pUtk{5}XjHyGb*ou#+>_gA>r_vg>|ziHt2;eT4+WASF+XaD;D zRGGae^PDTjb%pEXzt{Ka6)%6M;~M-W@!xPYF7%f_3E$6uM#6;rr+NDGPiI80Lrwqj zqJON)TmJm?A3y*7+wt$!O7Z8C>tB;x{`~nLe}07gpI2p1{okIP+RxwOKYw1Xl)n-E zYxe#9zE6AiJM$JJ6{foUywvZj?7wl{%_DqtI~ZCyE59?hsQXvvS3{~NqVSyay!kal z50T}1LkdqA;SFp5Im2X#DXt?{{u1Mi*ZyI(3po~yCQb1!?k;-9gE z{n&oaV?V9&7WYbdVg0je z{Iu5JTLjHXcFkC@c%;CJSC;^Rj;`6+LQ2tBHu5~}}lf#o+dfW4kvzHd1I{S6El>4)uC!MdiFL@mG>G$mAnOMp7mNm{gc;K_* zU9M1a$9z_lDW5(pvG@p2zH6NIt;}i*>&~kuK*a3zzTR4{yS_ct`IMVixtV*URkXR>RTptXTeBZ$)O@YvnfIxma1`QhWSf*zw5}A!Dzn&vqeRb*1?Gm9ep_m9T+jw8?EJHGAU z84JOFKnj?@&dVduXW8EvIpcEtcDoi6bH5K)^{0>LL=gL$?|RN&=l$HrUE3_r>Q5Xa zS605vs~`h;zP;m8xM{d+RpQrms}*D6;=pIq*UAiUDRM`=U2(i*W)@BX|83s4TkD!*wpR<$i)R8>NmeCB|ayT{2z z=vzsOaYd@oH`X+wS!DIsvv#1+V zOdy2ue4hsyz*xmluy4Fd#~$pbpRoXNGQx?v^ap#}%fV_q4|cU+#SoNGF{BM+Q`0Ee zAqH`w)hVnK)0;bU&G5u!D7BXRtpV489PN)!9S&FDDVLs>ul~G#<9S)ogtF%M)}a0T z|3V<*%-UEM3V1cfaSzl5e{t5py0OFqacaD3VLJH-eOZBzb3xGe0C{DM72qQ1R`7|~ z?U@f&6t4&}T_a9hCI5&i?}uv_w&~>GjLNow9a|4(=AAw8u#5>sYw)bNmNy;Vq)s%s zH2*3U`9J#e_)i}&TYIK)RimczM)2wslHTpzsXe(iFm*VEUD3baoV)&VHNAD1^xRyOrAU#L*PTigi6gDV{T zcc4Hh%K2jP5ZJj^2`?VhXD?(7QOAq$0%%gl2wZ+Sz?*&sccXh5Xn@T{al+@I(Bm|@ zbqKd^W8evVQp;`_m~@3%-bUpfzD%kiaK*&y2$x%!Hw7`wnZ344W98aSn9rzp)L$cUzQIZhL@_VqwH;eOyx>HJy(Bf;N*! z4V&pHs2{SC^!FLX!$_5S;pdBn?EX&7-&`;_{>4&XcSkJ7Qg= zU|N5G56 zaNYoAtQ&~tctCs12|fnu5^-VJsxUD#yb1z=$^~38Km~!+96$YK2#Ea5cYoupnp7n8 z04Nl^^z#6=#693d(87GNLx|_w_%Yr>R0o`7P1>3_--dW%)Ubmu%aO-ojxHR^dT#vYY?DX7!wN_X2s(^ z+R%|$!yE4aeHdEnTV|OzCB}}J zf|Fhr7#A48w%4@<#|w*^Yly`UvO*T9Yz7x8K6 z3nan%OS;jTl2u zvYhZ4u#O2Gu*g#JLKub{FROP0BL*ZS-v>+x1F{{XFMj&nH_qnR5iL+Xjsm^Jw6P`_ z-EANQ(h4DiP^z>^6A?P@_KCtin2b4=*3O> zu3tY&>VnnkFaQHdsECe-?Gk~n5Q;g$PccXE!RO9Ea{wxD%0%E2!V}u2$ zGaTX1*ZK7P{XVR(0cf@#dyn_r)+dV>v%@->qU9jV+U(GQ>J%9$>Kszm zJqC8(jSB`pTzGu_SifHGo+nJ`g+Vh<2>em7_$(O=hFO~z6VBAIjJ#pMw#&>QdaN42 zVFDT^Z^)WQL)R=);_F3pa^S8brX5+qt}|(GhbL$z{gB=O+FbZW%+dk0xwnVY!KF>zcsO7J_IC2{<-^xwxIVI?SgrloTN#^R zV<5tv`8LaMDAljCjDRi>|8)+)=Dq@yjhbR|$E*+E#y^U?pPYbFV1AJJCVZ_Qcv+0h zh(J~h9=yDQ7+F}18BkKX_9D1fdoaZ~Xj~aXT&M}Akr9A}s-g~qlrffo>q23TOd3iF z^}7KV;1f_vK&Qe4(Z+T{PqD?kCuaP49WyZSnD}w9p5SZ&k0p9cNvP1b3C_lK^ZlV4 z0zsS~(_<~-!XiWUfNe}CChNFomMt;}-6NMQOisbWV%8WWIOWwxf;x*_4Ss?49GFQc=0`xu*r479T+7)&_&`Prh9kg{}Jzg zBQq%#3>p?sKU|-!A)pLkDhy_w2XBip*N2TFvwCi=HpU0ffZa739RVUe=k3GLxp~ic zA`O>u*gCQ7y*3;qU<$Q)*Zz#3dCQ1l;pX2xVbKY%hnap@glB>7uut$O_I{d zXlBG^dq!0MO#|qU=L(`X=w#~dFhSW?LJtgi;c-~#j%Ka<$p`^6WfB>7~ts^M)`f+rU3peNUjVC@YKpVG_U(z@O7A~^EqU+02M&VgI(p>(7)dBiL4Z; z^6KDVqy-y{C4+7Sq;o$5&ha$e_x%8dp96@?&=F!*?8NsuE&FRx_gGovj5{^riUY3L z7DSNge13+FBHT?obU5yqQU^L=7`&t2EB3uz1gnyy?u}U_@j($2#2qtr=`Ew)QIpQJ zfY{1gQ^W>t&$xjg79Y2o9{|Xo0gLjWkN5~UCZPT20rBSr=P`Z4dBGkF7wR4th#HI& z(MR?o|q7VHkdesbm8M^G zN*EJFE1$;>fLy3kb+_o^4b`&0eFMJ%PYnzVX2WVhNbvg0-F3A)YzHfxGgpVv)@JjT85$!9Pt{oYLZi!km?ChTEAvhGTk30G{ z2yg=<|G$&N2+(cUfss40EKqGc4a9K1#<0u_c`hBe-g#b(DFMAeK;W(xZu3EK+Te+D z!2r^T2qX*m6c{`6gOS8X!C)&K{5O!wd+jXsS9(f%k<*U>rs&3y!l#fi2?8_jU7*K<%ev zgy5^~9G}0g#Zbe6acVE_{>K~FE^s&@GE61n`@S=vZK!uw&e4g9bQ(rw6d>4+b&HM3 zIJjUwQ~BCXI|butm8ry78oG3^ksC0qIhr&E)RFlNOxa>`@z$54Hg?~i@|dR z?iYc?4k2(D03+M9yJa z{O~OoUZ6ngFe?$#`&_52wMcexHU^gaEvcDM3Nt>?JwS98JuyW9@B}Lhtid~`5l^_- z4FEc^^~mg$ofUpO_oxpb2lP(#iJgJClyVfvF7XGZH!wy_(kj_%6`2pFoLhxPiH;6>zS<&^(FQX|;DI5ofvs@7k>DrN&8zNT(OopN1mIYD1E{!MhcrNB+ zLzQnA7_40v>eJJSkt!ip*d3f|x>eHmHIOMl1Q6t!DMmd{>aT7AqyTKm=oMt0w+>q& z(ty`6%MpB^;Pll!k!Oixz;lOC1xIRp8mux5$Fuxy`7t_8#F}OO1ttJ>Mql7$a4f_R z2U->E0)|9gSb*Wy_8h1-v&o$$X=rcqu>oP`LHG$n!&sHJ9#a^wIROfb+3FPs*&8k$ zKVf*v0K4BYj?7vN_iE6)4tN+wXe)kWM+LXP)42eBS>(KqfkHCQJ|wMA#}M%17&dod zx~K;Jo4(N(Q~p{%7Y3|vRFOp$ee}{;{@6cUffI2D6YCCf_4c{$DFFc2 z3ls0mE&sv(z^H0EFn)87I_`(~nwXac0I2u{Xn80Rmjg)$M)sINMcne5+)9EhN$vhV zUL)!mqf3DrU_m6y!?@N_emGD7~2hX=WT`_2Po>t@<*6qFTB?pU&Dd-R2e_&pR; z8OlN#=pzrlGXxr_z)DXo_I)4wVO)w3d{1Mh0PBtr9cZAL23&K8MAJ|KY^*9KS3u(y zKsH;2={wMKtZ3SMJUBXLoM|_PjQNjd!la7nP2c6rdc;O!44%fUr{dNc3=~s;aQ)TX zXyONRy^@Z?NfJw0{-ER*W&-l2n?`}I}WHtzW&_*1hq^Y^konvvbBnA_B z$(BUe4|EVq<0jw@L`G_i5&nGq=69N=FbhB{LarfV_^uPV@blYr1>SQ>c5}fSA)5(n zpYte+Kf=-7SjMLm`7Ivf;8EQqrVeblQVOSIi&zQK|I}kLyLb_RvPn>v9K@p%^>LtEmGh@2%NFWp;!bwT+cN!Tebi&7^Z`@$TJEuw>F4prn0 z2Mqwfagdh@ImxUeF)Qj8r?F8tPmCq$-rcHkz||y5-W#wfmbegp!+0nHT%^O(7*Z2D z$8+ZX*G=YC-SPV_0GY&dG34KSp!B>tZw&GQJst%EKB`F*&Vm{*Q^ew5FveV z<=DhtPYl*yL&E6Z^#-^cII8pK8g&5SH_;^RaU&_4!I=z+!$Us`qlEolhIkmb84V{_ z7#RieVXnMQF;rIo(B>C__6_(W4|r8j1I~ZENJZQ+s`MB5#gUW=#y-saSh|=D&~5R{9cBUu_8=4W>vHwfANSZDB41y z@ojP?Sb!BPQCA3<2ZAF{OlO-1L?d65OJ86Mo;~530iniwO94je$I#T1SK2RX7Vfw^ z1P~vDA7qgODiV$pgNlUS0Z~EC0IFL{-~2WGq-r$AC%iF?1)_hI!o8s-DlknVswG!nfr?l^d7fE5rKl#chsg277{1eROj_1ZNMuVJ<&5Y23lr>xNP6#~nOJ!%&; zpbLuPbUz6tP9od$4eoF}H`X|UE(bKeV(=US14RytsYS5NHqvt>EFZ2CPwTeTE4($% z>$daM0~NPQ#5wxzn6OZ$5vhleFd-#&y7ZBcyMsB)gQE8D;({}LAqNy6a>>k4@*C%V`W9<@HS<2EqfDGeYvN#WnMR z5V+?IJ`9Lo$Bf`vKp{qBEMfwhz|0UN+%ZIvd4N_XW_$tyY5)?L!{Z)R*?Yf3H;W43 zMXsIy1LH&aXB;NVb_kGhKi>0pJ#)sSVkI$`05VwICSAjF(qY>=8C&n7?2|6lvLmmChwVo2Kx0IPDvb z83;>$1@dBUpJwL!iTQ~0&jsqsHA2F1W6y-E0zMD`6lesjA|Cq2Pair;&4Ps#*bT!4 z#YFvh236_ZFbR|GMsUyF9gGY-tzfBbp3(3Mb4bSv*S%nF+u}gOKn3S)317Ah1!GE< zTS$fj&Tz?7{8Utm8SD83|A|uT@iW?Y7sxRWcmPvSKN&@4gK^e+Ps9P_y~iUh{06j# z12ucXbAV8~sSI~(JtIzaiAa}eZeQB0BQEft+X3TDq`fiyUSL*O#Hd)p(D$gl2Lo;( z=j}Hh&`ld~WPC#Zq!uGzVMNh%nLjZ5G{H;c9}?n-8l`dJa_4f$n0)RO3SfS9L&LmM zG`0-$|CqYTR<}(vu0n+0ravOU3QM+-tcv-+5HRd zc!2d;T$Bc&@$x@Ax$jM^R^9_SllH9qB6SDa9jKeOU~iBU_7X38bnTA7+JSTj(lbDHjF=Gsg7IHg!OTZ|-j{E>@eLIE!lYo5F|}aZfEfhZKL}m`rR=a3 zv#Y;6z-Fv8Oeq1h9v}!HBAIkDCz3TgW>%Sh5-%1Wkbw7ZC_HegV1dpT2lJlVBaoyC zZb+DJBus9%3{ql@VG1xxbmTSl?n;Og5SS-pTV7c%7ivWFQ_ZaFLb0?_O_~uqT8#?< zBF|}I@L#V0lEpAXrrh+GZ@7;FvKcewgT)yAQQcvFBK7N5@^82A5FF!<!m-m?`D zJDBt|3dK`?U!>jj@Or}?9Y+(#vy3pc03t7zl~@LYadvmBDtiJN#xh~^=*|M10^z$z zQ=m2DtmPiSI{App#9MyW2Kw8v(Po>^4ZdnKYhK5Bd!^JXq?VTfN_Kp#rOz z=&d4jh-pTuVfr{}<~Mc;>^U)oy8db69)h_npc5W$n+j>bncj~1*aLUF3L3!V6o9J9 zUEiBF9_5o#mLJv&2g>8+hjU?ubT>Q&H-luyi@|jOtA%Y^5nlzC zNQakT1~XHU&ph03F3*Yae1NTd7%prlHg~}Bv&9<0os$LF2GSIOJPQ=vsM`;#Pb(nd zj`kGu-K#|grsP6!0NU6>Z0|th_yBm&J3oXHRX6Fj;Kp%8V6zWkz7><#T{%3J07>Ks zksS?BG4jRSnd1j7oAnFcSzl_&o-xkjsu)|SfZ?+nmU5ZG4b;FB!I=%1WyJY`SimdX zJAX7)Jkg@MsJO{f+|Iy!atW9N(shlUaLQ5(I#eY%J01tKKEsD8z?DeU7Fu~f#sEx+ z$Q|Cs!bAqr6#t!F*Nt-W4UrbYajp+)#oJxmemRquvAy{kId{9^K7I!q%n*T8;`$iI z#%jYX$nYlX2Q4pSDnNhk_@h(i1(x)CMdd~xc$zDlhN;#)@9#?hn7&9-aU0DG%>D)I z_4<3sn=JIHFG_3V6}KLCBJl}%w5)_d!R&PhrdlN2NBnua9_JqWhur$_B!;7@AK%@P zkw0?;&0>zcW`GgVa@mgiuH|>4@hLbiU*`6TTyc887)<-aP3RR&aam^)eew3#PQrl&VpDA+EzlHzKcp%h?hac{YrQvDAMcZ z&CeBLj?6S9_7?qMl`wn9tAXA{NmijY;aE4`3X$U7u!$df!_!$# zXK0XtxXX8Mjk2s4XjdUMmJi`OA7!#}2jQXOXF(2Qw4uxlV^`m(FhgWs$ zK>+vrJu}$u_XpE}TH%;hOyg&g75As*M9*>VM+K%Wzb3a}Z^F4D7ckMAh%g~Sqz0@ zyMSeipmb^bR*?OA<@ZpBG5SovMp1aV_PPUS-numfKs+JTgTrHF`Lef3Oo&U#$RFl$ zej`5IJux|yF$)ddgeXo5N|M2A%t!m~4`zEDTf>ruTZJ}1U?i+}0#P2OhC|kJjt%$- z&2H$FQBrfh5}@D;MhIC<6Ng6q$==4Olz$|2AO3|U8W>vJP1sJxEXtvH1b`m*Vk%Z> z?yB8psk#@Xa~SZm>@L)0Qqj@>ATn^H8e+VFcXj`!iT`1CDD<+p@RUdzh1c}m*&07+ zpSdYXrQLVD<1bXK)&3S`jTY!SHV*$x0uF}dXxMP7IyVcK^OlLQ!+-2wI$ za4{HK5X%+Ni=jI686T_MF>LS?Ih#A6?$t9j)_+z^8b*Ry0TjBE6VW_DU8rq;{B*Z@ zzZel%sUPPLh)96WxJJB^MV!+CgP38H2K8e)-+^o+ZjexX1Sk=pR&d=rEhpQM>#%BkfzPfCVWi>evAN&(!d}DOibMLHMIb!SvPaAh`_a7J)Dkx%^Tx0Vh z!@E{#m!I%fhq9WSlxJ~jL9t=wYIB1_H;nW`*s!s6?}HQsz`jY3jf9x&T+S(S9|{7` zV;&%5NfUYPKn{bu4>$oP29seOm%*}@O%J#i))Wf3vkWWX4+8!>?1m-zK4%5K&&zdq zfti9EL0eb1Q0QjKd4fI({7`=psMBa%Z(m{FQQn0QHUlvF#({ zrEaX>%xl~hwH9mgjFkNj2MQ=Lf!Tv2j6^6M16cK*x7+!)OGuW8V#%Sm_lLNi>oFMw zu-4Gu!Sutf910^*G!AQ0G4_MSwdl?&`Z3QZ7$S|2*>I1L%2cR6%-YbUxz}tP3?rbM z4!`Icv=?1|Vh$atyddwpU_M{p81ldcFQ*iN2e+koet|k;NzCT$W?r&>E#X=67plXt zob`*_tO`5A{b0!BxJ~M^0TQcRlQoW5L_9A@=Y+>Lg@+o%@i289p}1{y~mx9 zbDF<9V#fwBBHRAqAI{xZ$^u?HGc;TUW0ye3U~vvMygjgE%+fu~xCNH}?G?Thy*t0n zWQ%f5WDeJ4cNHK}^E)=$INJSv3E9p1)M54pFL&WiR}Jc(N>OdYwE5^}qQw6oeu^Y1B!iMV<-R|eW=YR+9Gu##};!W*mGQCuAH4lt01k|Fp zb@@HF{|bZmWr90h(dcXiI7N$E-ag#s!%NHi_7{vtrspud{kA4IJ#YY1!(BjQnkGft zYvgpRI%op`-Pj7#X080P#IUF*xYV;Bk+mx(KBn#F6-)+?odm5s$t1YfPCi$ZSa!Qs zg=X9aw`@D9X9G}72d{>?!%$mkqqSWLJa>ZLu4_BUX@t8xEPt7H?t+X1rxTLP!ko9M zd#piv59F)IRCo0bYHCb#8kneNgxx~gu`(1l&K=Ag=E=DwU{9-h8uWT#UKukYxkmQX zSq%HOMb=wJn?P9W`5+GX43TFKyHef~66g&ptd^NuZ%vKq>#>2;c;oW1S@7k!zEI_D z*~tDI+V_f*;S5H|n>AS0&whK?^*Y)@B8NK|uStKVeC?h8VA*LhLv%`Iy7i*FwU)tb ze6ge3b!PaPQcN%~nF<5{7N=*BcINX+z@yyTpt5DfOT)jzGk6|Qbx27c0vw=fLi@Mkg% z!C3C+WNZiDMCv|h8LS>QKhT~=HlBgkM6Cw%cJYx3KlVUDm+seMhc|0ME6@X_#R;N; zlee+|p4nJn8l02ClW^PY51(rd3{ulFOEF*zt!C$U%tTRko?XemlgzVm? z!G&u78xT2E>zseR4f?fTr(fCFxHxD=6M^S}=``ge6(}9EUhE6V+W)>kQ^UeATg6HW z-mQNHLBLPLC~Fu{s@UQK$em4zz1=NarY%h{07yF`fVij->dwN%>J1UAkGOEd?h4h1 zxm^J$QNw`-Bx{o~?N*1rrHgVZ(ArLjCO&9Q&;I)237D77EkEblfg216=1n_%n1MU7 z)A%9P6q;Cp&&4KiEmXYyd8=~()Ma@nPq6YpNAu?HZGzd&?>h2h>X)U>SC7WN@OQg1 zN&_1(X^mU zfURBtz1v04J+ccA2u>duQSd0fET*glx!eGrGItY+kwetyL!9pH#*eyGvq@Gw46DG! zr>RA2r+8cUUqvV(C^Zbg3^@#KKP|wpREUvTjyvt8q~$0hAGX&Su?crs7#G#8i+h?t zV1FyK+IbTT2XC7Uy3>aUNlG5mf9J_r&8ZbE7SO%wJ)ST6} z=4_9~ZPi^#zbr|L{3?gJ%-v3f7&YS;xM>7q=jGOZ?$!*(3v}^JSFkd1!lNQyI_^9I zsEgs?!!jnw5fIEgwT)5x<>f&9-5|}zq0L0yaP7c*7hgqFN=1G?Wdn)B&K3h=;Z7-F zMw67R!8a`J*zgDEuA*F!4I8dK7Sq>iL$S-g2bX0k(5&k8X)Tc-FjBR^;DT+u_Br56 ze_(wlJQH}z9RV0NCd1YPkDyk|Jdk!Cu8s*GSXTt1NMm%)He_@lTAqN3L~5)VgQX8k z_O?X>>R&kGw%_;Qh1*U^vLbH@eJ6+&2D>>iE+>?FqQJAvYfsbV)9$|>rsVOk<0;nQ z`QAVmjDO|FjxhiTfuOr8LaKGL&|&YBo1E-9Tpy{c!AE^M38IceBIrD}5U# z-qmIcR|FQiKX&0<9>9CF!;!tXKsx~^(|bHF`w4b9eQBoS*qBmFZ`xwqgEs3?e$$;H zEG))cw-58Y5fd1Z<#2f(ZkO85Rcz=pK-y-%;^zRQ2`CQ1*ShwT$Cz0NLa~&g?yirB z$YX)@bsd`TY^^!^a0@)I+elEEydN6yo|da(`*_c{^ zOE8Kin3*PQNI2WsFTF(~`;HyCGQIb9gT)&8cek8cS>KA&1$%*74CtnfFh~2nBK1F4 zhygE#YNuO_|C9G^tXq%mG{4pOsKv56|F4+<8fEF$_HY%q;T7B z3}Dim^e@=ab)E~|N86r(V&eLeEi&`2t`AD^9#po8MLULpXJ%V}2Y_5@hs_vxvZC6C zF-8OAPzP7BL6cZ)ZJ=Gd^qM&P8($9u zdyG)L7Au4GZ7pbtcZ1kXE2$ZEu(b$&S(|;^wMlpf|6U!*KsL0NVDSxitbHz41!glk zc}sr9YI1-XpAe#Y zWeYIg>k|%H$!MtRW4n-K3)$zpv%n2<5c_UI%jBCJ^OqY+J7)7*xW%>aVM~Z)2V#)~ znvpC5{V+aL^n>wzDf{z1=-E3gbxUSv152`(PgL%Z-SJwiM3X-c_xo!#!M&Ms5^c%i zc@3tK<0*k2tVaT~F84_p4bI;tV#j&23iio>oX=tY$gs30y$B{O&=fyq)mef>80mik2?p(TZ&h ztO(vX``xwz91Ne76k;AlooKynywxEO0jH zj5Xz;B8v`+h1d2+!P-6Rz=15YZ0yx3U3hd0CRy;kV*8f+3PL|q@wm6u+V*j;5{zZf zjkrLPaUDQrFjB&p+~ujkrl!!oVc$@5nL!ESri%qSkchSm zdw!@D3xzv=qz#JHa8MfO+3W|&VxAdjci8vGSp(t%WUSav0>iB=dtmdrFzm%_cbiIb*Y2g>wyJte zNkr;VU+o3% z^>MwdaxuCg5iwP5>P9gYW^8NB#$&t89S`m!tOLb3C1yMXqfvHdLGvqV8z}cGPM!dN zO1O;3q{Y3Hrm90SFg~RlS~$M_cL)v=%BlB{-5h!KMU+V$l?z?E#08Ljd86sq{xrr*dnyU%H&ACTxGOne1mIQajra`mdA_hV*Yd?fTs{K&~JGHCK z(5d}-ck}G){`pY_FNn5MNzMx{d(#cvjd-{Nhw{#X(BuO3Es3;E$ID{uZZ`(Ij9c5s zN>7om^)bbx7Gml0WBHZGgUn8W}mqL+suck`+=B+IZjhh@~%(aT;s^ejJO$m zX8gkuy1O77iU;l7CM^3Vc9A;wsQ%mn+rb?UyFX2cD=Uwea>BuxwjX$yJzHwM^AF27 zH}ifYsda=fl^*O_S8wy6d^T_hlwiPnng{mW z@ezi0o3s`CErES5s{$A`laG)~PTmhhrMoQi})zEx8vp;q3UQ zX|qtvvg|^ixDk#}y=mX>Lv#~7J*Vl5_HngYMP?561I{yhii9sGcNpe-S$UZF`(diQ zaVi|oF!br61#LHMj{8iPO&|Cj>TV1=Km#oE`G9DPrasneIbyS@!lL~8VSAJAqNU7E zgwP%kT;4qq-E@kWjITh%=J1%aV89G?#lk}&Ak5~y&ucvB4zx;cQLMu-@pGr18VTzF z?8dy6KMybnfx}0o%!smhFqlaH_xmexz$Kit<;A7J~JwWQVlY6sA zRGwcKPqVt*lONxZYBy@^N8+0t>WpWB{X%<>3Ia;)XZCXGl(c3u3gr;*mynwkL`rieS{6NCE7RIlrJAR>w0ns?)WBpl<>GMz;B@zN4tbRU!{!MPRxKd07k+89 zyW>rV#BF%`$nOy4s~velYyq!*m@dQwAN{mrL$M>dwef9#VISFKndxR`_MEZV@r%vY zxjq7xEHBt(!+ezb9$&XF>!q;B-9GhCLtlYk|OO zLR#|z%U`3mk)Z{|FtB~(m2GFsF+J_XjW5rLnjVgri~|4;@9+sSd_SlynpZz`ID(YJCnA8RBa*n*xBgaCln;laIzt0@pQ7KXPWJOcUV(f);@}YiinC7MT!l) zKp^xQP-!Ak1Ox#=N-S_YrT7|^T6gPOb@Y_|IXTqIeT+&$C3OX`H|+LuC#cc zryj+%r}RXL>yNFjkF7{g^)-gpwehC~Or*c&u3X{V@z31PV35PO_-u{J9FWKg7b=jfY zWgh$K)w)gXP{>42ynL9{f>*II&vJj>lDF6)ghp=bm*i>LW?c!D`8DdQ*ZvreJ48V{TT7Bm)c%d}coxa`Z6vT-k_1r&ySw&xaNfSTW^-%B1bu_2YVEDpVOej7AF z`4%ntmGmov(9FEUsO8AotEph*^i;onr|AHHLIBI642D22B?4Q4pKj#2y4kO3d|1eO z^H#x`l_8FR1jt(3R-mYd{(vd9$F5@AqV`rKB%#97CE{rR#Xgt5vKf;En)U?;p?4Q% zH>jvF+$qxh$eG8LvnT|YZ*Odczc9Z;2mk3zNAif0?S}8Zz4eUMS<5MJ`y0`w5_F3T zUk1nS%~7jVAnz++bzR5NlpOD9MgI3}`-Jzs*Y5x9=zU!z+uE4*jXrZP&3WOreM93z z1SQky%gtd#KNuHirkyTsa+m1XOMRJWd#3J^KKwN9AZ}{)lhc>rxfRBjr>&P^Vn%(Q zJftK^mh;4UIpH(T9GylntoSQe!G3l3R?oe?vUJk$FvfeZQX@sFrRd=$4JWn4Vrzx5 zg4tKvfxU?zz>bz>0uQjWazvlcL}+_iF5}r$Uy9@{AFheFmbY$OUWnv=t%w#l$FeFt z&=OeISg7}VQ=L3gM#h9`g``7D00WnWW&_JlCg6^6XR`|8EV&xmgZjtPb` z+fsWogRPIAxng%b%_H=qxjKb2X}oh<{F0OS>$eq-A?_E}8c<(*Zg@CQHw00M*1t^H z#9ft8GM$s0ajuuHb{k|C-XBYE9)W*;{+i5<_ab7o&)003rX|7{>`O01$I8jZ60? zA3R$(^?!}iOlxRa9PfJAIMEk571F0c$>FmU3DQ4({+bD`u(^@r{`Oo9lV#)SXC#Bi zjjW8dDXT|WKQeR%eVwLHwlK*mD{{Wp;(7X&ae?VU&Y(n(auFH%WC14AN|DJGVSx|k z-~+Q?XVGok;gzuWu6vB0U2~2yGHQ;XyX;srW4*q8;IM+BSx6boCAi$|n@(kSQc0DW zTA9`x^FjJ$oD_LJ^1j*yvCALgeexnd%?Yzah3nV628*;P=RH#^k{=u@=!MHP?A<`? zeN_7P)OBoEl@ai^C4&y|*JDBz9=tXPV z$Gbysk{;+V6TEZOS|sWT#293^_g*b^=wT1NQ;pRM$tIagus1r~%efixx1;xE4~N!$Ac(vCAqSC6n6@cLAz?{^rJIz`-(>X^-FtPpG8is% z;yR_*`1EaSZ{0WQqd1p6{;asZEw;VcTVjG_!b$9fBx)+3Os{&V{fRPsBTpO40;XOE zzoq2ocw@#SpZCpOB~6E+wJa&Fq6P~0dTdFhQHj-~#Kngq^_~&3ToMighAcDULA0{e zt$y5>`lzEWob}`0Qg_-nqH`d{w0zD5EAXXh=Ec0FfU8p%5=Q8wBR^kS-sHDX=K&dj zvU#WsAt!lRTDCf@Pv-^?7I?4JnNx7M&~9^nM`LaL)UUG5XuY(VIJo&T+cb=!vIx8kqE+XYZ3R26# z@&44v~qfyqfLy6C1-KU>a>I>GPboHfPv)UBRjp>jxY7Qs_lU)IDA+gl=n% zJi0gRO|Q4@T>q+3trQC9PWBFT=^?C6-_|;IZ>MY>;8-%krjQLl1Jt_~Rqp5!A*8=7K>X zQWv`H@Npwn?v}}V|Ija7Tm=zO_wAZS&s&P)>UB5QZlRYABPPzJ9yRF{vb;el55qQG zRILN$lJ7+q7%+4yywGTh1zObDjaNd6PTQP&7WNNy*!Gu~lua^fdpQcX+-OtgAR~tP zne8JR`_tY0zyz1dn=O`mBgch~u&83ZJ+wk8HqWtv!Z=TQ9+W@GXtApq!!8l zf{!4tFa_(*)Ruq16c;>GPSNz74bX>1W~rvVY6sKFKGdvVvNCdD z5cEY;<{R_gZu#Krk3RI6I4<&ZnsHdMW}Sb|V$jy+78YLkCZWNDHvvmlWw{k}nO`E5s(u>BWcgUYrbKu6&1av8lrwxB+R7S%0U|n;#g&8+6K?X@ z9;3SJ2}3N;lFE?|8Jg!i_r}3>Pk8tyF+QlOKd`5JmOA)-Rx30E5>jr)9QFtqfY{I}1!6n?(7J z2t;|_R?yN3`f7=-VYrXTAI9TK?=)@>LS7`L(Z~=z(S!rh^9QH%Fs11tSArCD+Iv^P zQnd{E#37zB+CxH}rLG%muY2OFV4TQ}4r;(a>d{0*Slf~1WqSL$ut_Zm*9LzVB?n<1 z;?P09vremJvWVk|KgFa)a!-sM2ln)`aoRA2oWfsd< z8Fjvl0x6T^RI<}7A8zTu$=(1*)P2X0It>y(-#h!#h~js+BZTlkp2S8dy@>6zC{D#% z@sP@=whE2kVlQx@yx+v0d1!WAv7} zbR5+gq>EwZX_fzKFpO?aXeu_kj&P`hdc9vU_I1#3zjzVAD8^#97 zUyocXyjgeHGTonAHasqps&>NF%0v6Xkav)P!_jeB;}e>_X0SW1wU^Y1^1P0%jwuY+ z+0}+K(~=9bR7zULJfb|=n~MW6+#3emALQvz%yF`3&ELN)?5Gy!5JLKp8O$J#ci33c zc97rc7hOtso5x~ADzEq*_3jlM3( zaQ0%-Smbrb9|{L0z?4e2IjTT&CpLTM;h^;FW)`;o9 zy_Np!5`lnW&`m1lj_4?4f!JdnVQ=lhHSw^2{V1m%a^%(YAg%LR%;^3!aJ!djX}~w7 zq5Py}bU6Z7IdA=Zpp#eYjG}71Cw`u_?v!E%QR?u_iJJhWQ8P;we7ldOiSg(kH2d_y zw2s;tej(M5?G?}VD?{4$hD2GrFSZf*dk1w}%SLM!Lvq3oj>TA7xM{@Uc4zB7~ElG*H!nmgXOuV%Hz?|i)HMmH*e+0 zm&wk~d=Wel$jjGuMCYN1{^<7OD`A{0k<>*Jag4;x_qqAH6#bb0YZG-r9@e6AHnH`G zbm;b|8|xQrXCACvVZe^f@+egk)x6^<<;ohRk7Z7NVSNBkbh`C!_FZRkT$^{QY|FLB zSMKR3+J4&qfVW(va`S!p)SFs~dUbv&jnn+>VUEJ3VnQbc7f(2=-jHhIC=?NTS}L18 zE@)4DQUi|ZiR-+bDHkNm9)0QfS*T$_fVi+KqU)+y^b1--sNbhWfsYrS*wcrfUVe2c z`0IMz_7~4mTPv5h+J_qaBRK}PI2i&fFQwTI3^(G2WcO?mYGb>XjAv?F1g1;k*yZ-3 zaRFhoas1>x@d~xIPee{WKKBiAD0uIJuljHd{f1LO-p$g|2_+p~|HJMjZuF;5?>(p1 zWU=h!3CAF}v4}MaJ<81`!#-5vF|bRZ2Ljj)@Rs&|t(v)-X82338TPS#y>T0fn43meK}mqf}sah^uH9m;qYH&<1U9BL_XJtaM1x zOCC_*2y?UI^Kx`>a+UXjoc*p>9ys3_7Cp=NUBt~Ea`u+C9-j)*1;!^SA}Im}sd*th z#Lp@n;!|{i+RE#zs{c>{e1n{|b8|zNG*&Xw=( z>^1~=-0%ATB>mI(@4|qTwzj+~(#Cz~p_;0Yvpe?6Lyl-nvk>NBH%wp^c<|*Y>_UGK&T^}ph!>G zKQ0*}9AO4-Ry(kX$%siv$cc$dOMxZC#Kgt^5HfXAfKDqQ zbP$eKaF{5{3I6?-or#eL+yS7q+KE&^^Y?MU8+jEMn3WsS#Sn>ffSld2mTyPp@0YcK zgo0YRS*cpN!GNcM#U7cSYK|d0M%^F2eyF z0jz)k{f-si#UFF{%b%_Bw1e$T5C9nnED8DpGO4qoKb#faVT_;NDvJIc9*W-uc2Nv) z-*008bpcE$`a2c=z-xze{)5MldH4@L0Z{$lhx}Xk{ui$Q!u4+<@NWtKH@f}{*T03p zza{+N==#gxI`l^~1#l zVs=daQku2EUfWAmMK4ZGm89xmly5;4Kt47%iapKHgqfK>&FN-iRg7mki-jp9IfVrL zCFMYjj(iE)<6g!5KsymXUF=zXot$`V<;W{+O0w@lfE{^bB`&{A#d36@*^G|PQg06( zC$NP*0~?+H<^A73yM}%a{~X$p+;xDDognVz#7vS_Kg3Oy^whY$Ynka|?3iq}BMVKZ z_4#Z^e�m2)OHR5N{y5nA(Xdh()EYqBTiLf&N*oR<0pu@Rp+V9=h6Rd+ETh=;#g$ z($U=q_SOeJyN7-Z{~X$p+;v!9xmdLyyw;y2?fAfAKv@xEyXs)kIoV`~q%AZSQnvhhT*CwYq0@YK~AUI)%bEYi>A2uEk|o z$0;0npW4U|gux&1?BMVdi~kw1UB=N}KM-6>_uj&+GXvCaPYs0=aU-tqLz2NJcd_}rlV%Pf=p zIEH#W`flP1UR_W|1Cx@KAT^CFa~V$_^J9zO1S?RtUf8_Fm*)BMDO8eMqCzl@Lz~~` z=Gr>rf-wTaIK}M_xo;us@k1$-P z`J752DF_f1NFh~}h2TYEbkA43hUf#zks5I_r2QC~yCazrVnjSnk`k4(>51Y=rlSL2 z`4OgcpiQ7{~Sw4E}9QykRlj337bV7>B7w8-VLvv2XVxR&A7v>l=de*`e- zE_nY1LfvI>?fT#I*uNIwedN-NEnIH9edxdj+>nrD?^<6o{Cp#1lRSqTAF)WP7A7;V zyu;+0qY1gUIY{%R(5*aP2*A6RL4QN7J7521=x-3;WiZ`)jS-N4K~HxvLTjaeYot#i z8}6EfX|_X->1lWjduDKtSe(;tMVCl&lDZ7Sh|g<$B?mE^v7zu#7OaHm<_KgXWVNp^ zV?ReIrl`jvHYHafU34(nPXpuO(PL6`fTB||E!CAa(LcCA_Iy=+W?P}s(Yq`@L$nz~ z4_UOZk0-hc^#o(6pv0P4jVNt^sL%Y(!tu}7l3nijFW&HCT6Zi1cK%V%$Mdlfj0rPY zis$>Y(?=i7^p#IDHmYHIGD`=IAquW!>b6{e<+lc#?VNv<(`Ws38GjIJL+IAUL9^BM zW3Ql(b;bhL*ldaAOW=s5kV)R+*dRjSA}KNR2ATZ3LBt|W^0Q_&k< zYvn!~Ge;=ZPbwO#C`7l`16z0wTYP86;3?7&Zh0lA=kJ!h(y3nFP)s)2&t?nnJG%+c zTeS#z$j7M4b5z?Kxx9aom}9?8JU72cJm%v~{ut>+{z9xW-Wuv#tm*gju_2ndqN++4 zK2~{Z8&r9YEI_#pclhq#%fr7dY|fm(%rKcf#rhyu`fnn(^Nk5Q+INQ7=ZCOFWjs(^ znVP9%C>i_vs9OPUT4j`2H}!6XGegHnLr-)*qRCn^!I(Q*a2Ve6B^E_i$P${x`|Zmo zXNxXxOk`+}5JMytW>c`ZAWUgSq6v9(1zJYwb3*|&$Tm00J#)DEN6Iw6B!iTYn6lED z3dA?c#-&YPEg*-}hJ>g`!nV7d{94@lB)lDf-=h38?fer~-vMUVQ5&QeZe)kpAX8NH z&7*zETwO&)9i<^@_~eetq}TAw4AJ;@;{5deKB}Y)O{J{#3=I}tQ%%)a*obUJhjp;L z#dl4EO!6flyufN!ZIZ7re;BBvVsd(7L*C-CpP#PYMSushGua{dW2@|`rI0~0_o3oV zjL$QH!T*dmIhx~2m6-OohE;kH`(a9|-%+1qK7{Q)v)Ay+%v@M8rB5>L6}BWD$j~h} zw{Ei--xH)<9b^;QeEJ(IUtm7@cZ(tTVQb`~_dq@VW{-9=8u1@9d8Nu@{ahvHMh_vm zS`SkBm3bJHCOX=bT7`dw1tnET4VvL?)VrzB4ev5a)=EE6GAO*oqmwqo@pZ>mOjlM` zd_&P;gaIB>ZiSO+w-!BQ#NzIJ2iLqspXaU3d=IKkMl<%~4p02=-2QWs{UPVKaRK+fxrvWP@$rt3V*vk63u#ZTd<5 zSS*$ZOu#+j8VcFv-dSjIYU&_G-@d1p;#;gp#B>(s$iN2JMu=_G@wRySt?>{PIZ+uR zFw6a|rIg4%54l%cSq-n4OZ+Q}$Tssg?wuqHH(LM6qHK6ceT}jD9aUO;DO*<&wnvGB zx2=$799M&9s5aQ|GWj+HBWS`SK13bMuvbS_!1~3U__Wm zMIlf69GfM{RlmZz*WA50IJ{Bk)%*S^y<&TOhlPif-qSn_8km@2y(w=`6@2X1;d)uOM;l*|sW-r|2oH-|~a5BI6z%5g@PPR~3M8P4%M! z+pMG#z0uv6R@T&m6kq2LjYY(m%>2U?4<0YgpJ{Z8N-V-h1!1V3r^Wh^#TjO8gU9h6 z>*2|8qg|C2g?im{bJ^t* zMYLOB1buHq%$_nt0q~~Bg=Pc%EftAx1_dq~EOy-TAz=Ojj+e|;SSAhO z?Yy>HfrtP~#OA3m&ezC`h4q<06F2>A+#C5!fM`G8fx%ItQONDcbNtkZZnx${vll%_ zQk|Du#A=4I(~*7_N2Wad!d=Kgt1Q77N{fQv&(;;4HmCsc8Edd3cduaa*>Jz;QzJc; zs4NML5BcgM`9Aq2NsOG5#It#&*b^haajvU~kh#RxPSh}1Og2~Eak2Km$v=16J5m3? zNB-`p5083*7)tac1N$5EJB6T2inW#pNq~vW)^iocd!zl7KajR?9&X>z5qkZ>*{FA`@( zo6!QB^(rGoh@ZFNPaauOFYih5-6>#NqwDbw!$_IHzo(Ak+w#ZpT*{}( zDYS+v&&EJ6a!iRgnOHQ2A49fa%m&8rCxOaR#yIaF#lrdH+qt=5A$B0+Z&yew2vH*= z{hCXZ6DWCpu2r5SmTV1P^pIm}*hKY8QKym-#OzV^=`C8GHgAh>&5uq8OC$rE(>Fzo zC~IUT6wSi_lHMfTbb7dwh4~IuV<-v^uPNKi9wFL`VEl-)=3HcV;SX)TF3k2g$`GW#U2S&0MVh(AAwLA;OsHaRB{ffB_(m-yKh!iL2bktXkRwdEj-Q?-Af9YaV+>`iF zZky`ak+F}C^W^_`3$}JtR}>XCkhB5Xj-R@&p&kexO8P&2LqP@2+sJ zZ<@WN?U7lSGEKmG-(2aJn)bhQlW-R?>CxLcisiMdeG)}ih^^{KfkQq zsSbWt2>-*|$Xx^pRyu^N;~C9twhhYnp)KVCo%J}cNLu-G*qs(74g*p(-{64vXvw!p zhh24U#;+v&5Hv|g_B(|)l-1Fv154F3B)CH9}07OS^x{A<(H7Dk~ z04L(Tee8kufW7KEvf%()D;qAP?|r$rRFbX7h_EFc%lmL`i=V9zGaTPk{{p{esAvSK zRElkFCzfY%_OBNGMK4lnlGl9K^F<$8P)DQvJl$94*eK@f`o)ywvAmDl$c_N4_-2&- zydb|1((D{DnV3jvs!rU=0T4;nvTzxA{q!%qgx*z6@08BF4*!GC7uXlJm)}t0uLR%m6CWlOTk)NL7 kwexQu|3B7(wfmNoHOGIQ|D=|>x?`56nvQDT70bZ?2P*C51poj5 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_64_64.png b/assets/logo/logo_pixelized_64_64.png new file mode 100644 index 0000000000000000000000000000000000000000..9c63053ccaa7e005b1a44e4192a1e82d78d3d8d0 GIT binary patch literal 14941 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 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_64_64.xcf b/assets/logo/logo_pixelized_64_64.xcf new file mode 100644 index 0000000000000000000000000000000000000000..00cc168c84315742d444abc3f6ddf6b02b0b3654 GIT binary patch literal 9512 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 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_raw.png b/assets/logo/logo_raw.png new file mode 100644 index 0000000000000000000000000000000000000000..87292a01ac36a273cef182e4c1123b295ee2c68c GIT binary patch literal 40084 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

(bJ;&zT#$nC4q;)KYLhd7*UztZA|& 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 R!$0BgNPBn`{`RBr{{eMc>zM!m diff --git a/assets/logo/logomaker_justlogo.xcf b/assets/logo/logomaker_justlogo.xcf deleted file mode 100644 index 4eec8810de7af2ef1216794aa51623804fd51cc5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 74299 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

6URO23mHp6$# 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 diff --git a/assets/logo/logotests.3dm b/assets/logo/logotests.3dm index 24a0c052c08906c72dd7e2f481c8e22739b929d4..4a19bf17801d14e58550451ab165d4069822ede7 100644 GIT binary patch literal 581635 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%0DPZGfYhrwnFBr3Cv%2^+kWsry|!FhX>9#xrfmK0 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

WHwEL@<0X2sgXP+YY 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%0A0ZeP-G$ENpv`0Pm>i}6%+d%L2~PnV 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 literal 798682 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%0AU76GPXt4#(h zlUUODf>;OKE?7NAMH$oynjnb;q*K!BcWICZg!vi&<&QXDSF2xpAwBw*R3ZU!s}sFZ zCYeO=l13r{ZCafq%`zD0bSxl4v}tt?Gs+~Fh%)IV6418QX^$-PmZZtS0y0EBR;O8` zOiGEVB^vwY(g}-iBCrhlZyW>EV|7+I%A}H*RwDXGK$_JV)hvU)8OH!|tCKKMCWA!q zpG_hG{j@rPk!3PTnp`X(L-fH;kp#*^VrOz8S{=<6`wh4`uu$`b#V* zk$`cudI-)kc_d9<7LXyv#p-!5%78YX#QYKo;L+;QD9V7gfJ9^8z@OFGP$*MKVquBs z9|2=;byg9}6qPg>2Li_3>XaswK^sLRf+qs>-0JKjlmR{30Z#obkOQwtSEyv zDo8ZiHsovdKVXzW8xC`H3D9$^o#`keB-WPbEs+4-vs#w39U*CgSwM!+b*m*i%Aj8% z60s&AK=-WnCZkL>i8Uk|^%}Nh^{*?IsVQlUb_$!a`VSMzRF{Y{MmvRlSnVuk8T8F) z3$PEX{kkYqOCrYFC{x&z)gqc@FmA@N4!_l8x+WK?Pcf-TaDD63eHr_gTVs&wC6Pil z3V|g^3p$_?j32hdWR7}3lgdb>UmI!Jo?dsXPe?*Bkq;cAmqnn`Vi14;-a7Fq2GWp+ zIuNFiNKk1L$qb+o$TP|!5A`5SE>Q*2CYBjMfZ7Jeg!O&FgR9f_#^5k*v{LB#QVSliI!-9;U(qin4;|Dr^lmh+a_`sI1;8KCK z&~@s&$}{Rm9{9on3=1lPN(-H!UQkZ_z!3Vwda%I4f{CEgLY9=L`spn21eu{fSPWqi zMNnxWPar`3NEKuS-cSz~JD8LRDlK$^dOM1O-2rH4HN()`5zN??2K|SnGQF&cV zB0;5vz5|Uwo1u-PKk#QIj70i1X<;+88};)lv~ko^Qer8+ECQ7lb^`>cA2LCIAOqA> zS|TQFf=Ub9qy4F$41r!jW~isE!~lr|l@_)~`%^#80eb;&s0WMDauNwDE$kQwP(Oo# zzR<5?fr`Z@L8XNa(~i{-PM|N)8}tW@T;pO|rG-BL0@P1CKzA_KsHd_-<6>E*g+BlS z)Q>1YR?tP%gT=6M5v0=k$$X#@xN(8L9ra+5T+c|PUy~Mo1!x3*7y$MH-9kM=VhxEZ zkk(&j0FA&S_|YHe7V4=gv5rI)NDKc21h9|XXMp~|_E1kXiS;ECR9g5rqn`sEkCjIq z&{5P=U1Eqt6-Wy|2L!Mme4USaV8f`Vro;vk2`VjorO{u4jz^`V4(K}SsU@+lL={L2 ze+dMzAKX@edN9_gr?$j~5(z3Td@lX2di*zJPI)zw*Ns_;3{_g#4-la9>^W!~V@&;N zBCkV1q=QNe-%bCm_tkTxHO7YWYAUar>2)AbY2m+t0DW9Mhev}aj&pN)-2y~9sI-^^ zjPn4L}`gPeDDcB({@CP-!ujsPhSr9!4FoVbs%F zVwgk~NQ?Od2+(C9c*rm6!CZrS+DdFMk)YCo4rl}(my5CSlZbjcNDP;#0%A@!4qs0(~WN$f09 z1=3=k1R8Zb-iTx!KRNBfi0|-zLZv#(|8R{7z zaiBzkN?S!{00HVTY2bM-0W<;+CxX9)uS7lL zB#xJ;0%>c=44@HsY!B){pHR;S5+_JhfwVPc2G9sR&<6b>UlZl^BqNc2P1;&A4m1Lf zf`RV9ccVX(C617&0%=2J2G9u93CN0iI7ME+XC%_ENn2aSfdKV*6X*~7GgV%H2qGO+ z+Bz~F2v83af&Ku%*GCekA)&Xh<{Y3s`jAV58a0{Y`G5%tWHI9nn?rEMTHfB^Nt2aGX&&>VUF35ax1X;-8@ zcTXyYh;HmA@coRGhL8^}ndGHkpreVIXc4MqEy&^|qYdEpk+t4?(zvPMLm;I2N<`bZ zMwmpR8K`B=XyQvl-9WO(enG}f;mnRZ?p|rnDs#|E6L&ow$1P@NextA7{OjK7HAiMwype=TGmw{o*%Z& z5b_49^;q?Rc4BNoEo;m(yJp)A(@G+s`oaP}1M)y$0P&53TGm~{`j>4pOeaZ!YCTqc zppF__P|F(g%&yrs!}O8}sJ|d{>Mu5(&_(D1#)5WgrjIf^PFbYI2W*>R21yK5U#g-H zXy2%lGV0P(gho)y8uQGq**3$Bk_brP3nTbW$irxx7?1eo3zlVFRw3JFm`M@>39QGe z4`z0umSx;3WZMigOG2P(U+~}P2mLth!fYJWva(pbz_uA?k<>u79;-f>*@ap*-VVr2 zw#_iBOatmKe4VFR*Qfs1wL}f-j%Z2efaLg^Zfog<2ML z@d4Xrm|YSB)ff7h$6ynfGXV4r4Be^jU$v|;&+M9QGt420fNDKveL(wWcA=IvYuA{@ zwi#kw1XMR9U@pa60owqOfBGzUs{2P+^%bK-oOk>*& z@nQf-5Tn}7DVaS;U_OUEa6N_g&BlP`5VEW>&Fq?OGxU>0Ky_0G`oQ+(rArnV1Ih$x z1hp*FtwOfVFpnezeqHZUn%_4^iXox78r10-C9tL_AQAe2@!&X^`3JSEB##%^HbZ|& z4WwV-1{U-I?V}$6_Q6aZYFT#)>tD9bFs~#9svBCcu0eb7QvmbXWI-RZ=hO_ zSsx%9({WHXAE|AsakkB{pdaiPWsP}e*KC_%VMzp3*XLMc!e7Hz0pc46wXC~@^)K6ISVWQn)q1S@z{1b0gp~RTQl{YAg8{u%ZYU^bOB>QKZ&t01GTIfjWLaFGb|=Ef$F9* z^a1S~by7w>J`2|bwJg)ELblDYxFiG;xVFby8~z%;3P61@n=jlHa=hw2K5#8Or(oPF zWZMi&NJ1ci^;q@6%r4Zjj9Z0ln_)>w2vj%JVZ9GO1ses#Hx6o9cM0oXw#~4VBn7JV zSoOioF4VHtt-EvBHp9{~8JMxd$ir7BcXsL<1D&|%z!*R$jCNtB4{BLiBwk?K49iGr zpt>m$eL(w0S;(lVU8rS27ay=~h5?cosBUNkzpx3+836hQ%v&m`Wz~E&&bAqrl>|Vw z9Cwr!3Oq z1Gdeuf+Pl>cF$RY&z8^!v`@Y<23W_L^+PQy$>IgJ&9I`R20m^2Aos%ZZAGQ+Qv#0` z3KzHs#kvCeU>pZC|DcwYMdAgv&9IWB2CAEK(Fe4TegH5I7y~n%RLg=sK49AnD@$VF zzBbw0=C4*)=yoP>AB=e$ehNTYnAxUU)?LE-mu)kwB1wUJ^*)>}onPGjypd%elABbm zmNg-XmBh9g2FYBYx*-|&;_%a0#{f7E)KPb;`&TV%%rm=Y+YEyx5m2qitPju!vvE+% znzd_8W7`ZJG80JPhD|@2fORd_bO4S6?t`s>Wv%k9(uK?b61W*Vk4!-Om_GsN1Macn z>jTSz{+~cqNeujW!seZCwN5E`0Hwc7gD=2X&_Cdw+pG_2SxNSfpqiuxavZr?70&}O z4p>(LFb?pOd|rt(f?Ag8uNzjEg#VAd_kgdWdftaO2}$UN-XWp)B1KwqH#cmGMWr_@qKK&E0wM}XM?t!R6crRuMA|#g-hGzM$!-Yh_wNnwZ$6*7 zr_Jn{IdkT;-Mb4U@Bwn12cUk;T>!`cTR6#pasYY#snq}06H?$D#TMuf=nH5IyDgk# zP!l_(3$#9x4IFFLv9+KCd=M?8$#jvRm0m)B4a~dZxMmfo#@;cRP&tu&Tn@J&%b+dmt zjSpc$=Oly5Yp>5K&bk>k7a}0*PRTDqgw9C@mDj0Wdmig%*g^_{>K|%KOCH8*yI;UJ zcupr#3shdKz$L=E8MYKUpn4rQ8Jy;BmDiz)g8U{Y< z)D9}IkfjK$n_+9A2CCO_k^#1Gnm1M66a|n%*3GbuU3rN*=~2`})DHKd8LI zmLjljhHZr!s9wiS2B$eo z7iwT?WPmN4<_ncKMFFIcbu;WBc|ZdHP*z?tueU4$B__A9483BSPFN(GfyEmza@Nrqj8 z0Lb~dp|cIuUk3u zSvSLYDF7099XA*sL)W!(&W2q}=j z>$u6_G(M=jOuL1wn_*8O1QPg%)_WzRs36(`keYTNub;#Hmvu9INJxPMUdK%ar}07M zW!f!d-3)sPA&|g7sHQu*3Gc5 z6adXXLisHQu*3EE$6aWdlj++cA`2~4-Ew_+$Gki=4f#x6S zeI{Q*O^Kil&?oJF;nWT)uXzpEfORt*D3m|~|I`l|P`_%6l>CCcyp~(Yx)}}G*3EFR5CU)Bx9i<{3ElNk zM_zuna*dvPZOO|nXzvf`3r^#M$}40k0_$e@gir(3mnuL8)DJlTumxmr>XRxj=u-mL z&G1Pf2C6S)s3Upkj~K53kRhF*lW(fLpic={H^U)93{hYL3~b@#7b>rir3kE>;c%e_sxQQdmOPvfa$I1TQSww!dDU_?&AJ(m z5CWij9VZzeM*;PM4!jN|NwQcs!>6Pa7_nk_nVV~h>ubxbACdWHWgYbaaXtq?JXFw0 z29+1|DFN$dI8um#>dQA`B@btmI0FDc2K0x5NGPE4D#f==juHwWfiIM3C>f|9YkUCP z!AS-`g{G00>C}c#3n5U|B}Vd4KhCA>zUd@`$}22)1fzu-NT4nr$w2+E2W1G6xRVT$ zZ2)W3WApE4AdxC$z-TCS#9 zH^cEl03`6mL~)XV^Ff@A0VqQbf70=nypDyoOxDeCf|LPGexFI202xp}t;AfD1ijN7^=Qxzz(Wk}CHO;yi z&JY4%tyS3uj686~Gq!%W+y~M{>Gw-sq#(v?_Q?>5JGFz#D`Y7G>t;ApsDbY`_+x0c zuID_ZPu0|Obt_`Xfchf^0kB1=pwpbC@`64kVBHK~5n|xrbPIm}Wa)9wmtD`j)a1)T zdQ-`(B3M)qKpC9Y4=S&p!~K_aGkjG@fsdYj?Ugq9HT~`9#|((s8D+?T`XPti7EbM; z@(N3ez`7aE5^CUb|9;zN?xB6nBoAX$89@Nr0kSxa)haLOQv%k_aJCQweW{eeX{=Ux zQ>q_jtefE+$pfBv>EMnM!`kcIGwG6taoWDW2$QtaSgrC3S&G2A86L}e^{SR2FCjDs z;)qC-J*$M+{5&f-)y#tc_Xwh6W)r+mu#_N#h0)k?5CRb5x^QZQa4aZ-e9|HxjT_Rtr!46u-e2%B!6yW( z3f2_F;0%WtBnW!Q9WIFLRTC^NSVxe97s_xglw*>sA&5m_v>^CVmO&8ZFl=2xbarg2 zQI4{Vf+)w~TxP-Qg0%%vj*!!jxw|_%G(NJ zVN_qRfgsA+_9$;Jh)JrEU}Hg)!!EEr%I_C!D%ec0xgg3>1{(*f?Wks4qo&zly?*CCD>E2yCC#{9r6gG{9(bNf&&Df z6a+u6jedy!IZ$wjU_U{W;kx+*QTC|d5r=~@E>Rj9s6mH(^iA*}4gei&hE5Jg zK$>L|{Xe*yT43;vy&L%}qZ?Hu=6yxwJg>CIEG zx79Tn+4^F*76|%lbg-6)p+?~9&0wp?pV<3t^M+^kWJ^4$MLZW&^w$a>7wCLV%Ez0u zHQ}mo@5#+qpC1_hgQrODq1W3#a?*nfS#asRmFA|KW#&s)^hF&XU=EZ&?@eS*x)G@;$~b9jywCo60fG=tlh#yi4&P`q;CoYLB*M7P4HF20i2wm zLR`V0zORvAu84KZQzf_yxT{N+H-0W*xylqNN@*dt>H12Tl4zKU`QQq=-8@Frn z=%xwKC2{rHZw*~AOaX>{_tf_G? z)yCJ!Yc&0u2g`Z1d80i>+6*5Wb$?9c)+nPK`Q4tr*YnfPqE@*0gG({UXSjdf>oF*2 zNd8Cn-WP-GBQzwFA6RU|k_jI#>Atl7igUAndHT{1xsOTSwzK(%8Cr~%1Yp>AJ>wG+ ze39$(ebME?tRw1FIM?*$7X~I|tm^x-@|7$@TeR(vKi|eHm7i=896Pei_~F^^Nql{6 zZtayfGM%h6d2jO-N6Vl4wQ|3)--fgrIzF`JjgZnsmfUD?xlo5ALst*HQ9@Fqi|u_n zZ{ql^i$}IwGk;^yvg_Ad#%$}Neg1y46El0wxQITu$S;Z2^;Nk`7I{3%Px7nLRwj80 z!M{(3_Pi%J-$hnBuW_Y#9f|9sVto?m{T{BXOBkuW-wR>Fg|0?<0FGrnJMTaFVe8_08{1gcH(T}%Z*Bc5_SBAF9M4wy_N?YM0Cfz?6xZp`pbc+JoBSwk^02he!dG&6!8m%+ zM_sjn*9NT1b7WxRr(K^~mzsE_Fn;s?ihWw&2~%R;eCVT?h@5SV5NV&j&qyN_Is;&7 z)fsfjD>tgn%ho%i4NCc;$!TKM^h~on&3j%2uh%Df8!HG2eRIF=t|Ptr_ZT0-0Zr=Z z$1^O5NalHs;Y9+e@w{v%ZB1@Oy2tJfdGXplk6yXTtcZCBJQq$kU9kP-!=5pV`gL79 z=(NY}6^>0zkDD{@uOlNHH_>~T>F;F9gXb-fo^|qI_P8%)Y73RA&E|FRGbcFA@O6`gaRu>= z#`kA2MwQyKNWP0lm7tJd6rDJeN$i`MVefWh-=^Gx%Ew?P3$8F=JPU_N}kd( zW*X|r6cZ9NsBXV?sfkAlW5)-(?lCO)=0pC)_l6gH#8fKZT;}!rj1Xyq!2EHV&)=W$ zRWs{7u_UI+Y2xoUuIuvNud*pNfoYbfRnOD5oi^s}gvE>Q^@(nJ-{rBog!H_~r5{!{ z((t^mH>7{%f8%){o1WL^rCh(9n7h`~uhZlPAFkTq;cIKPZI_Q%`JpEyF(BCVw4SEt zWirz%WE&cHVq$FPBlmhMZz&MhUbdw9WE*PE*-7SZ$xF25Bc7PX=JSvszvrEqa-obi z<7B?L{Hy22b`jm}TX6fAaivY=Y+{is!8p&x=V-JW@>XSB}P| z3`>+cwKp0bx8k*2hQ}d|0;CNB^T)~a@-L{D&w4YlMQoayCRR<)E@73Y(LHSZj4-1= zCrs#EMHl7gZSB+m;j#L|jr@82IyFIB+c>a={^MIcwn$JXIJVsF&fInY580GBFF@|@XI ze`rfR?ytn%WA7=WW6tX!<2&ZOnbH&Cc@yL?$mU`2KEun*5NRtft$Cgn92^`JV(ep^ zRgD{=*}cp@*V*SoyN6=l>;H4)r+2&pjugg((c@-mSq5f^IbQbJn271EVqX0&%7ZZP z8;4?$e?>oId7smYRhNqd_YeC_qnT+|)!dv1h2DT%*|t1$wMk2B#hTXVJzu|mm3^Wa z=e>FF*G=Mm$697@s+YMqbzCyVR;eTQH8xYv(Qw9s3d``CJNr}S#ge(Y?Y^X&8D z55uD3X6B6Yde`>y-Y0GLQr8!}7e0B`doreQT(SI7-nO0ldh_or7?;r(?F}FFgtwii zSlpElqP@}g_V=Qq|7ZKx_dk%QEoL1$Yk2!u-`6qUk16CqI;h+J7^KgQx@d%dB}|X$ zTKC(SZ_@uBQ+LI&m<9J8GxGBmKb+!dkRaL|J$C6$>+QCZHh|raqXXZ1%ktWb7iT!L zu(357Om5%hh5J_ORytyH<;Mzs)mU%(#J)2<`xMY?DahP<2+h_b8H)=^?GAl>5re;;!QT1{44v{ z*{4pGDqUiwr{~JDF|7xl@wCZZ?!tnv&U&_)FR49hzNA(pF@T$w5p_!*?Rub;p3_`K z_mCSkFN!y`8q?1hO?Jsmo4a^4;r{i763f5U>^G_GqsVJTO2vilnd)sVZDJoSFpoc# zcp``P)R@YiwV7*q7PYGtotk*0FxE{hyVJ15v}f;^FSE%SUd(g=|@2+SX+ zRrI=M#g=I_F^QR`iB;1x&GNMBdGT)@H$3myt~XohqP#w_Wiy2IJgs(4W7BSU-h_`H zJN>`)ye&Q2ja+o>d(Yax9Sc)yDkH!Z6eGG}H5z%5Bl52UdEAzc9)>YGQ@B zGjfacBe?~8m(JrM!9m8!QLn|1|EYbyxLjP}=BvFUM0fk`Vf(G^vY%*>oQ^7C&z<(j-T@Y483I$z8#k{H0H%=r^V zmrWj5N$>Jxkte@>r;3g_FP)6*+1cy=$yIYJ@p& zjEw1@6t59CSRPHfi=X7eJ=k=%d$3{Yf`heS+=C4Y3J&t$gH62t_~)AaF)jPNXP*z( zN_(}aaoHR5!0X<|CCkOF$aKWJwc1?o%{MB>-6(X)yM6L}@2fj1#YKF0(EHHNSG_G7 zSB>kr`8RLx(y#x&-NWv#zyAa~f)+AlV9erU1EP0+b-%GMZSdZ@x=5GEbtrn5w_e?) zGoqp^tr=T)T;b!<>jssM?z^m9bX0V0<6M~+QAdRYDVX)q^tV`Uh3tmxe(Kl4N1y)f z=#)Q#tWjaxJ2z%O@=0;sS1Iz-@$YMT{Q}+B^c|E{uXTD}$QQma{nYTAZy&E#LQnrh zqrbW>FQ{)Vc5m?fauIsgo#_jYey@n0R_Aj){kuu#^LY^y{445LKJTqdYw9l+jz?%b zQ?+8v-kr%tm4CE{EtmLP@1~FM@H8xQ{=s~|?XsTiIQV134>z1RW{oQRGonahz?!Vx zhW}hTuRce+el7pcC3T;fzWHugTpxKNp+kl&-X`)y!sXL5*Ef+T67JIZoO{^U;tKn; z&pT&``&0C7*CcO}r!lnm!s5Ur{9n&DZ#w?=q;Xo7O{jeD?>eYeO=I_@$ zwRgYvQdI8mJZB5!{3vJhLmoCWUz6*nmRDMso>ttL$8+i{ZJzg}JoD54%`k6fdH(0L z^tfj7T+m(adHdS`a$a-uuyKPk#r17*as2>k6ZTS49|=FY;iR56Z-b9r{666YW;uL^Y|R`n~xs%JiL2*vN?~< zY`%COk{Q5{=)7UhdGDE?H&%KXJ#U9RZ8t3AYwNqq({^{c=e4?bd7S3vVT~iR#toNt zc;x47NuEH2=XIQPem>^BM49tqWX_98O*~QD0`5 z)Aij4toN21c9kERoF-OH&os-^s^|Fz4lq1S^*rB!-~FD~Vt!R08f9B>eZ5t&jg$Ue z&l@{($j5J%nCIDh-`T9IbG&QKc|VzR9-G;34r5G!Fd9FZRMMRDxZ2!^6_-5Q+E02J zJnt@FZSvf9X7v}RYIYBETY1`_{e|cK?I-v@+0o($t!ss#Xv}f%y*A7WG1nnKHFI9x z>gQMS%PKm|3Q$eWG)>Mf!E{>nyo6WF86I{lW=M6P=pFw;v{#pqo|j~`IVPgtum7&+ zan5_V)n~rTy?1#k?Rn^{KVRMBncE~s&b34KSvv(TK}0eGyr##^H0QiHGmU*-KUrB} zwb?|*dU#%Y+4tP7bDsI%nY;_jUQ4>qv(0n%Rj7Slgy;S3XO1=(`xgj*?B73X_CZgV%79avplVO9`|{Xzw|Z!Bg55ZWQNZT zkEG|#Ymy;O|9HmfX30EnafrXcuBPH2xIB%iDQAtwpG%FW1IDiO7*GD)@OgNzvdN@A zJG-|!;p%zS%vTOAGd-`7nO^@(nYiV0-Z*;pG_N+VVqEp_GXrYSK0X>rVH!{;FKum3_Z>6Qs>> z5iL*Xc;nP1Z>s_8+Qp4APF?OKURtiVA4DS`l@e4BZ7Bs?i+uhE%Qc#w9>@Zw)vsA4HuS%xif{iSeOmQceND9g z`JE@%chaFu%QmeM9=o~6$WItItt-;LSykHVC4V?qIGM-N3sd8<$^K`0a#ZPvn7lJR zIhT09YjAm)b&qrPs{@A=Dz@A8WQJzxV$P8#etc_C^9$K^cdtQa@!=0Wc@X%qXM63ms|@9lSwaWb=X_b|_p5@$cf z$;|EIk;0g{Y^^EUeQO&=R3Y`INXQD&jxIV%4WQHc@ zevubrn%`zi>z=1A7-D!{!qF^-=V=$O7@ikDcdL;fKWkhYy-@nIZIgN4KbkAY8T-Tc zJln!!`^P=)^TZr~I5?=+cb-$UV5b)bm2*>G+^@^8ZqKE*H~WrG0=cm3!|G4>f#kA_NTA6SBPal{bJ8%9qk8M_cq)X3H|~1qv}a$?i5q3Bp7qcyesk!$9_oLYC10o+WzLl^ zEE%)DP}xFyQCYS1kUQn+rT4*O@AB2Hc&hOvUYC!umDB8=XJ6skz1F^}#a!7k%et5#hu zlBv(dA(rRSv@|tM%r3Ca9F$r9p80OowCZ{B#pn3v#Gh*#9u^r?z`sg0Juk^B^~7V% z(*3)h#}l2;9$fs=q@_EpRq6-kDmCK6tM8X=tm)h|h`9{lcD_xHn3lT^6xDg6gH`HK zS&?C`d{pLxn=&6*Bxs-frk+3_A5IXX~R_Jk2(kHl3)0NeH}HL zm?l+C%{0p=ns0TsE}oD!-$TUxp>}?>u^Q!^7ym**W6qO9mM&yv(4So?qD zdDn9FU*ANYomsrP;K9ykPImw!IprJkqB`V0#aVNn+x{?j#*!1P?~=(y4Op80?O8R0s_JG^`_24L7ft@G`TZ`Y z)9Re3hs^E?C4Jc=>mk&4^f3M{9sf&|@f4dLw5B2Qk43)NTz|38h%CuGFZvG7QbSGJ znh0T!>wC6;Q83q9&yV{?JX~{$&suGE|6}Re4%5%Ndfso%PfcpEIETK|^gO2FdAX&> z!SmY7{|xVP&kNRqf{IHs-dAy3ysPKg|8EK6XL3HMUWZLAU+gH>yFOlb(%1( zd(yE5D-DmKC(S$CC%Gr(dg+l(|E?!Va~qI*_4Ds6zA)KZJsxNrvVHcAT^X7q( zT{Mm_Sjq6D_Tr+*k#N46DJn3HCs}s1Iiu-$irSsF)#LKE91pgZM`|*jd z9P=1&+P(U{HOi%*-fV4)*z+E~g0S__+?P+~@2mUSZ@rcBO5y4a4%F|ZH#6T#*+JgG z$hT7Be;F^=z3TPI{|xR@PYRO%WrR!nhlOX&8lE9bmXL6H|9IB$@N_|;q3Of2X3dfz zW5x)1`))|)3>iW)goj7S8+d~=MMT^qZ|2Pw91*c!+VkM7(=QtDcRgh`uDo$~zgFs| z+siENf8RLMseD|)3tPSCY7I*Af-L*XMC`9Ju)j>i?%?)6aM}N;Z2t?1{m)!(i(UKl z`(Cz+aR+|d?Ctl}81Kaa)#9c}SJ+y9nzz}24o_a*xHT_y@A=&K4;Z=^v~-s@^u`}; zU-ZLDQT^AiJGF5_7OhkHhw6XzWmvr_LQ`tnpb7>k@!fS;MtQZU&Oe|`>(dS8zEWG;=r>B|dMDZN`Hv2edCRBANAKl%qM*-O zi2QQ;*;?KYcY8)EUnV=aJn7eW*IcM@ao6z@dZ{+qUadMYzg|n;n%!Lfnzcpz1jFZD z{(^G8itO^m&=Q(`T(iGD-2Rs~`#6H7!u!v>UPOCsXoTnKhgx|u7 zmvKu6H(BTZpv7cgF~bOv#;qNsh0X%i<8>)%9b0U@MibMt=11+U4=gjya?>Hu$i|*g8zQ^(V`ltA;nL<~i$e`;sL8OFQ*q?An@# zyPLOeiW?v0=qxX7$BXRG%6b-_w_d*FaF=^tt_K%(OX7KUZ?nJP-o6ij=XE~3?{(a| zStqZ+j*(YjC#EJIDU7W%&8nw$=$y{*u32;CFI)mhFSydmgET_q0h~7Hy5wg&P;k2S zp-~V5XmXmEFShrW-g>1q%hRmqnV*n|&*ag4q8wjjA317L63^4ttZShk9bUa`GSB-* zFHtb&y4c+w48ne6*1mE@MGus`5p&00oElHJ)96ysqUebF+Q8!P8h{VY;Mn?LCa&F+?~S%zTEMJQydi% zq>=)~R&9~M8Q9&}Et!5X*ONys+`Lym(XC^)BTEbF?KWney7~1Q`slB!^ttDg0{Zw@ zI+x8=rG|cC^~rKyzj@tLwqK#)b#qtKKMVihn`d_4^h9==)h%89I=WSB8oeQ$&~|E) z`CP9s%XoQb{E-)WLpiRbeOX(z(f4)M^yA7e-Rznp5M z@iQ<%i)=g9pByA*5oQU#2Nq`LU$vc9#%*})*Rl)KH+XIT(%qkLFI%JZjkjv!dtlqA z_!+B0-sL6zi3rSr5Exfm=g&)W_L(o+yIosl+M6x$hX3ngP4W-VgR6}*X|n~J5rmAJ zSrWK?i0IeETQvTdo%iI$B5fXhrh{(JBR$KQ)_z;LytloT15O)$a0c3_(lbpOt@7f& zNndm;OaWmV-`TfEhfHduQ(|b7>H5@?`-V2qE$L08Sm_;)+)VoFqd?Kd6x8}2l)a}} z(vyf`hrIc}49K2FoAkf=-8~yKJ!tq1^C&#anAYNU4e1w<+E7B;0k%=4XPPwHj>*sL z2uN*c2TE+$hSHOUX>Dr7*pCBJ8zQWW^AKM&$QLkn(gk;I3Ts@_1FGB3rhFYDKY%!>W!(pzFFAAnr~<; zOPfvcZB_@QHtao=)M*r;Hl)?Qf3R!P7Y#{CK==)9;+MFe;Wx~q^ekgq>$dgy$~0!1 zembS6Hng8szV?u$4-W`sz}iNYp0={I$?} zl^?MC8%pZ$UCygc(&*+5B5h5l{z=dAM9+Zm8*0Jc1luH&-ZYA(&GMPg2Ik(ATF~?D zJSAVO-Zu|_70`Z@!Q5}!wV@Ij%`&F7%Bwqm9+29wSFy+0dm5!Djb*EV_ZzOw z?AlQJHRjm?)7p&;gOc7y6TJgs6u7(mCN}ZYuY3;_wARb84bN;?#a_RFfb zX9lEgoV4j}o=VXcOn2vevvSUo#rjsY`nUQX95+X45w?3UKGl z`GvM&T5COcc=v$RhLTbP`;LH`vW#hM!_q_N15z8FZmcnP0nmoKYubXNH`7|KlV>{z zq&Ae48bF(5BeH1}jtbg9-&3UmQX9^UADg>pXrrz&)t$BW+E;bv2DCODm7xtaG)I*iKhFKW@xmH^(UnUBW9=#joOT?d(OPa=sQKj4Vs1RD1+;cN%z<{Q?WjdZ z({^8cpZQXm1I?|&2JQRjyX*^S?Wlp1cI=sMT5IpufAhD1)Q(FbE;Lf=nUB`Vkz?A7 z=DuWp_hHaSlLJya+Qn`=H!akB@@Re9O&b=F+NH*J)WTJ}rRV-S5|G-lN7@&Qsur|w zPqSyLGle!O&!$BIsU0P!ec*R)TB!Nt(SADD?)iY!j<(|g6SPxpM=c&UZCCr@=_Sh# zX{om~U)!N&trOZZAhlzU^lRyVa7(oj?W@iR%-441d+lPH)sD7PwPU`v@sFMJ15!I4 z%2HDF%nr($#B1ItbX}`_oql81fYi>^D#`882TbigJ#^^x*;(3HD=sx(=k3vm*1u&B zNbQ_%!MWMaRl9jJe+bM`#p#w@Z*y$)U3n^`*^0(`YjbR5{(3W?Jyweyqb~_a+d16^ z>Z6SO^i9_pA*fO0YXPYp=Q$p5VN`L`&ee8byfe}9vFrbQZ|-zs#cgb)c508+GOl{Z z@vkNSxpq#sCfs_UI;wCM(OUmj+wrd^|G9R2T!DK9^h`G`Tu&Y{SF876K>8j1jVm%} z=hg$&6`EzcHrq=b4@m8Jm~1~_rgrMc?=}x=ea1wr2uSUC9Lr-^r=H0*iQ8DJjjl4L zgu+~a;yEkZry zgqXmj@XrrBc|CT^bdsSiuSuiklSg%6(yRHTU({vNWA@eyxQ61W#r>qc;i&`~N>%W7 zimQ83(yRHbqwbIb*8;ks*g*DykV;VrG?c0!Y1Dl3sDmcy)qK(yC^p6M@x6d?JvNYi z?@pzt1R6?JkThyOc~qAqy_!$@pqD3p@6@BNn~e4`>ge8Yn>ReOCtKo4|Jwrwf4l!O z#;8puZ8o(MR({if&7bKOHFV$yPQsiDfpaw|W9IdoU1t$Vm;hFkgU=Q{oQKWhxO zcv598;Z4#0d1ILM_^7;_vbQVu^{DT7Pc>j%NL9dXP+qa{(W%orwDYa`twi{$MYVNK z=4$?*`-k3mzEd@QK-4bpxye<1ukLtvNSntySoCT>>69VWq^jZ&CimUll{Ml0rH{C4N!Iw4XH*F3clTSdICpT(7>AUWEe2h~={jIS^ zwH_;Pl&@0dIlX`M1P%SDW7h9}y!Cn>e>#!n>^(}D;7_Y=sag4EJw89(ttXV2PVHEe zam=uT_Qq)1^Xn+7MQ>~_^dk6X7`H){3qpkED$|ewizl~r2zfw**@XbtQF%CCfd};R zhA7RvWiK)RCva8S>^!(8cr$_61k|Zc@hk%^%JItXaAulmmB(HW=ph?c*aW228IonF z2iH$8Xm2;eUAuo4!>d6Us?h%CkcG*xjdDPt?d9n$Oy$w*W+g=Jh==V8k4k2JXYvPY4{k2b$=A9c`BX;BXlz@v2PjCNyx#&ci!KxBeSi$2PJYVun*l%OwUg#skrIy* zB&f9TJ^CN}4G$u59m-Qw;>CCo2~}G3b@q4lh#j_qZqTcQU~xf$N{hb5{-qvfLnqh_ z*C{1fQjnn1VvOTBryd*g8n{kr!7{vvgeon@0*(i47xq=?L_aMn@p6I$l@`87|5J}b z(Z=XQkf*$01wn#Ji^+@=ntJGnJ_wuPIu!*g2@+J=N_&^i(h_7+g98Z|Z~gN}Z~b!c zV-5yx04l&>mlCMFDbd=?PzUQlKAoQVs2hL~16)c#-jryZ%5ZI<(+lpB_|E!p>Fm8v;*@bngmqdB!#I+ zz{YkvQy1i+PL@Fi#37d(kk_r;Egv=ps=6Q#b)s(C0(nj{sJudUM}UC_NT4pP7a`;5 z4^A?uyiBJy#2^J^Kj1(JxnK+E4q$%(tqLlyT7J7U{0~TAJD@Jq&o*LzaFRjgWjeJX zCJ>aJ0O9&!0xCY^->1N;KZpA->t@KsFzaT&a2h9J7bh81UiaGlC9Inv z7t*XdCErB-PBN&xcPfK@5e{B%hS2t?kK;J|18oCZ709dRt7+=bkPCR#ru0LM2>|v7 z%H+@W|Ej$9GN(A}X2``qZOY9P>O%eWTgU*poMcdWg)Bv2-3+;LP;H7a3jLDyr)`{U zq4K6EfE2QBhS+NW)lE9)5R6mQ8!~XLkZ2N6d6N`6Bv>~?92Nl8>$u6l{$ang%4;uk zinDHpIBWo#qnr7V$aaaO0 zH{I6DbugEr4bUezXQ3^eK;?C!vFEXFhB&MNa(v+d0AxV@c3Vi&T3;egP|q}#(J!3ZLFE;)6oGX!j1p>~dL1_zocu!NO;G?TWZevlN*>TWM6zDcg0&6$0@?!l zqdx$h+Ck+NvJ`=JGb|?5K+aV>(1Hx8-`*!B>F5_KFX&PN*3GcE5ChdiLaeVaSHL#_ zXaj)LoTc*mDcyfrH^UM_3RJJ-Bm?Ad@(Y#My>@>I>tGrB*%cA#H4)lWWz zVOgODa!tq=YGAF4wH*Ay-VRRV zgUTx`DFW+eSWc*c92dAYgbb)3asb#DoP1N|^>euYvTlaug%rqFJMh_JthX^fQE%G9 z$v0JAVM`HMH^T}-4diwBS_wB9*e>=;R9<_TQ=D}(tSCf4^^hNHeym?GUIW+;PQIb? z`Z?TxSvSKcWMWf*S&Us3F~HfdewpL7XOyJ{uVV+1co3+MjFwBF~O2 zL`BGl0EiRNn8-&S;sgkUd^R@X05l%rC`X)tMngXG7)Kcz3;D=nT%v{?$VVPzB0yo} zBeY+iy5UFwRLQ>V z@Bd+4GQC%>>erK58l;7W21}On8NE@^;+k^4f zq&*P-P}&9;Vx0LczZ&AT$HTUNuY+daqpw=|h$9~reHqahlA>|-k`no!#C5sq4_!VV zu2nqI-)Og$MVlC*k)Ai&W2DXSoeq~`Dr|kwgAn-{7DjoHMhNi$5Lx}acmncUeuKan z*v;7ONX0bE`H+>G<{1&!dMxLwj<`oe4_stk9D+ItTe8UGQGSwSkCaj@CH(j4AlE&? z`7W}ed3c$TB#zl%W+Z9m&of_UG_UH!vU-~pKUJ|mr)rEQ{mlVAHKR#&leQ*C6^L@> z-fFuKulU4cgd?_k5;wn;@aB;to(+G!IC$*EA3QV@m$|}X0L{QBY?+?+))N~(Fumme z7o$mVNM&h|(Vy%qY>f(NAo~b0Roa9j2jdtmz&NIF_qh`2OZ=k&SZ^PX6sq@2HE*q* zZ+|$t^Y4GeAS^$(i0Aw_onnl%gh=CZ1l4nODag=yYq?~1muPaDR5d-*EKjSR7m3#v zNh8q1Bx-=8=e2wEQ2Jz^7Y#2GNR8)(nzY6|jwMf>l1sak^que+^Lb5~$m}5VIGdRp zLKd^xRWrf!IFC<}_+3AbhlgvyVd3GJ$HRhy!$LwsCCp&bgg& z=67HDoH17;zi;biN#dBdkq;Wq;gNe*#>(ZfD1yfV{{6TvSH1N6yLq&g8yXuuq-sz} zBQ(-7cN=Ll#N3TE=InQu*RVq5Lp%V+e03y9ki2KUJoCJD4kBp-*ag|;)UL=h%Xv=8 zG|wfNzU@n~)94(|kwl%tna>f%n8TO6zJGYKk>nrE;WU>qhd22o*&I$Y`OVo+Cq2#L zG>3B}!5rRFR>ODoj=(>MpB-1ClQCL2jS!g6na?=q@J=Nky&`Rjl{`iO!0qFaLbc-h z8#_R)Va`Tq%;D|7Gw1a0j5!_o1l4nODX4U4XeH~384}XuG_h)WrdgiW=Wx~YIEORe z@Vxcuqc{J%p66dZZ}k{+`Leyn$V?MxDeT4Rah$`Mw$I^QJ^Qa`?Zc%GYacG1&B{kS zF|F;zLxMFdf<0^I{A{e4>0z9kp*vU7h$EjXX)wHPRB|G61JJQBA zaG;N;uBmK!9#_KfLd4;DJlV3ZiorN+^}Igp(h_1ABDlvRh2)1}C2DC^=a(=T+O^MU zgh&rsbtwkvar&nzu2yx_Q=!bO2poYXRZXAlrSf;lYSWn8q$N1#X=UXV%1GnHs9)59 zUjMG=vCY#zGp%&+#*LnJ#);8(PwOM2?_0QNkB9%XF>lsG5(D@>lC2M}Dp?_Y1^prO zyFT!|hh@JNDtoN|A9!AnIp=+y^~`W%KEqy<`%CUS>3PU!oU6@4UDp1k4c=KJ@w;kO z4d+QsJW@>X`hxMN4NG+XeTd;<`AfVOlPzyyIWZbygh(3%=8w~A^MN@xXD0ig0ZmR5 ztEOj~1kJj1wN)1H^53?ANjj(>Hi+|I*!`Z!cS;^o_S_;~A)JNB!khA@7yi z{zOD02_bMme5KnjlRN=w&hY++kC^KZS!U(#d1cHbdn*T=HoQFmZB*%*CXKeM$AY9A z9$^Yt+a#0TG>WB7yI<-yNHex!kFum^2Ez_{^M4tT+RzRU-~8^LjhPkXQ1b2}o^d2TF`lfN@Gs z8m6@m3-xmRjLACFdRJ}hB)5-njx%Yqp+*2g#*GZ)$L*okUlVW9_+xfnN{T#HdZsP@ zR=vJ#8j!Z39sCmeKhwoLO3yN;wRhf3oE?zbP{QQ4x%HF}wIPl6M(DAE0jUk`K#6bl zw0_nHsz_sLQ{?>Y-vd$`C)=pfGfi5pV(g~D0j&*ZNc+e@=~>3K7O?vpO6u=v&Z|z+ z@MuB%KArCPG1~upgr*kkO|VTe=}n_p+O(~9aaTb0G-_cV1=yo3>6yXs`05WFKTr3c z+lB(t9{=Yzfpcc_e}1C{yx)9KH=%3KiuV}%8~PGMmNBh)FJGM!kYgGpY;dw~X#Hhb z4Q*8EnI?@^{c7(`0jbT~kA&a5xo|1{=85iu_kUS2iESF08d75`{3N{Is({pn?Y`;2 z;dkF&U)s?&EVHzk@IsF(0jUio{P~T~j|a!)Gqh2qXPPux-x)I=3rKC=ap-BZSADam zF-^_2pOzFE7m(Vp-G^UV7q_rMWk=hv%+ltYfg_s)q&Ae0y$CBCReGjLqvg)m>&<}F zCjE@j!5vB!O){p@Ugu0-Vw#$39m9SO%zFfEcfZ6njh@ClO3yN;wMK_dyc3YNp@dCr zv!^OO)1=YfEjZ!cfYipRr_na-X-rddt<=PV&jzG6l#rva)Bc8Kqz&A48YT7jCg-&P zX!bkIxE7ZKwr3-QLqI>8&niM(SmG zcxymvW7@%I%9#LdhK+jiX8#>|^>Q`e@nxQ$OP`-B_YKeKV10Xw_r5&RDzC0p|71*H zo^?8D!=7gCXG~SC9YTQ%!zMV{=7vdlH5GR}zA$O6J09sI1DF(2f5#&%DPxk<%Y!O5 z=<`;Tu7;?uK(8BZ3ZE&gUk`cd!wj{`>r*!Dyzj+h1@#P>OU;__NJ%|3a$$iR-{#jd z^ z1zqh6TF?tI%hQZD9A{}e+LCJ%t!;}8&pBxmus!uf({I%feyfhLYaSd_BmPR5eyoTu zVc;K8`t~=r4M@nCNk5dQ^lQIuETyZq)?VIH;`O_xH8{6&72V;5J(F(!QeDq(`l;WK zt6F}{zGC%_r(ez5-l;YIbH5c+8xa3S*WI~WWj1z1%wxzhrnN$OU%o$}wYgDq#=JfQ z3L4s|(lbpO?U&+x0`sYH@%4+gg1uoq#zQ>AB`G};HJvIXXj$f>8%HtcCkTeitD zbXjabjsk4=qR;E)yUnj^_zm+YJ6xCsq1E|& z^Ow=J2e-GF8<4i47VJ%SZ7k_cwXAg0C%SbHNNuPEJ>A~ZEa_<^hB1A{J{*wRn7znn z3Yq|I-nz6p)3!Ca^!;-SOdB-0q2BBK;1O$E-0)2FWu23LSVLVtR{KE1G@}ju#2S%J zRXLk#gEnV95RlrKe&eH!V4L-oj{mvy$sGErS3);;-qlQ3ZKb_(VN2UIqYXy}+J?5W zY!f+Znd2$Rf4*BYM*$yg1lzoGuwbR_ald*6>Ou9VXCdPsP#qv2uRyFX=CQ;^c&Sy+BYw)e8{fNm}y~O zXbGBryoi7FizqH3|CF@dpO@ry#BP5T;mi87nXkIg(73>)kop@Zc3%6#uIcjE8v1aa zQodoz#}f4Op_8VU_#;ux*K&X6{mia%z-h<79zbI^E!2GSXrENxm?faKOUZWB!d1I; zt?xM>(ArT0*v_qIs`=#6uC4DjBp|h;&GdC73It@& zbkjo3r%knqA2&aeW^G3;T(zrJbbHcwafwy&Si^sAJN8KX-;7i(*aMlLY^^fu(TBnEbj#&?_JOFaKbNhc zw``s5RlN39E1#{w)qu7gA2CSDc5|n%8rrc-QQsp+qnbs1Tf_Pju=e)gHN65-JN8IE zG?S9;rk<)?rsL=c->=tl%w1k2TA#DU_vej$1$FI8gSn269Ry6z>~fDuo?Eu-_*1_@0qJ+N86RMR?cB6;n<=#8 zL61284eCF)ojI!bOdBRZJGYVFbjqnH^Fe#+| z)adU%ZtFI>j2JY3wYPaT-^f9KO-*+CA`gwp!La>DG!` zui1kOJGIt--WSZCp5y^kH-B|&CGGz08BaQC7qERneRPv)^gXv8-+trVz7Y>Z`5r#l z?%?syYFVRLwhLoBec3kB_t3Y`_g%24u9ffBidyf-Ydz)ETK{=ppx5zs3&w@KbI+C< z)U24V{*vb(?sA}ozTlA;Ub?wBuinM;$@l4o~4*&YaT z)1tGf-E>nsYaQJ3ql&H4jCO9eV}1kErj~YL)h3?{NbT4od9w*U)6I5`(oOyS=9>Jz zT`~HWj``YHJyt6^7=O`Gv%6l_N=R2#kcbi0-31{C+L z*!gku;`i8WcPK3WazOS>j+w!>QN>LQHQzcJ37P&)V4g_QX1uWo+o@V`M&PKT&J^0p z3!jV+NZauN3e$$hI@oRGr*_H4%)GOvmkCJiOutL=m@g$AT{yopaO zoq8ty%S~(T#A|Ok{w?f3Ux}IimgG?dw;rhaBem8NfB&tN-FD}*V3hE*?u$Mm3-Gz1lbWz}|WR*HCOA-V<|cC{@ARDNcIzzL}cO zhALd-yRHGXG3|uSmXGooPcpXHjw=u7JCbou)AJr6=#E} zuBYa+j!NfeZFA~T*G*xr+K!fv?)|oT!!vubC7$$;QG>tTe;H%cCX+UsS_u{Mhi+pN zss3)c#h1V<(OsEV-#zG7-o9#wOaHURV2k^OvV^9LO89rnfAyI4_;^7#Wp7uWd3R&S zw@e0%3sC{yxUr8le7_l7$nDVh>BCJ|HI9k$?fR_5_9hu?>ofB1{h>~mny$AU+cv7y zyM9y--|72GG|k<$mPH@`)BZ=CdQHGI6dQmU5I=Fh0B)%B6{Cxr)eL$QH)OTw+8?o@HN+ZmOkKFodJk%B(Ge6uc1!egz5 zn(CX|IG`Jf4P?J(LwB^h-kmCbr>^=+)k==Heg4+$=<^oSnz#`rPT_md`vMrSYx3Pj}fhpvyi^Gpa~Mw1o+W+)yZs2f4@ zfX1u`EE-%#<>8hEJfH`S{kA{y)jgk`2lSxHBuGG=tVi9{8rPHZP{D9Am}!;AUJvLY zR|Xpo(v;1q9$Y`YpuOFYr}EhA0X^!l>w`SEl>_w2ESOa=hadsha9eDX2jBL)hYS)z zPPcU@ctDFo#%zKF$mzBO0}p6%Kxvl^^13}*0iIlf_~;+MJt$El?sh95Jb47cgLWVw z?)H!a>&Y!N{O}<7prhNZe%1pX^UxJ62EW@t0Ur1mK96YrD@$Vjc2Vb04ld-$Cv*i2 zYX1-FRHqX=4`>St7V?uDzi4;25f}AaGHngMLEd=mH3PuS+J_2mUHc)S>kf)f? z@H3I%LpxF*^%e$rP)AWg=tO{>RekLK1A5d0od{2DiZs3rS;llk<8N^+w1@U{3=T#p zw|5ZIlNNM9J5V5A1A`Re_5p|Vqy-Jo4y*%>!E%KBBBmQH=7Y;*EX;E(WZ|ien zewuzd+YRzy@U;)d)Sa}j0qvlcK^FEO46blSf=Y{efOg=v672?^ArA(};({uW7JXFh zr+oGu*FYV(4hAFpz$ZxqNDF!GlLHF*lsV)<9k>n#sG@=@kQTP2Jt-p(bs!IHfa_o| zE+I%zX)&g#;|ia?#Wf%+u7klZQcwlb!uRNZl!Ip{xDITI>tH}EDM(Oh(bw($9dxV% z*MQEr4kn6Xf+~;}eT)5za_|fX*Fjt3I#Gh91PLlF#yF01X50Bp+635~_9`Rs(q;hy zl@?=xeLMgSU(t#-X8$QG@p33sfVA*E`kyJQ^^_&rhW4r;@$$B7sI>4IyWfD6&nrSF zwsS>^S3;ozq=nyb@lF!%0?@C}C(zE71?vi`Kw9{XeIhsL%%@*)4cGwJsUlciFd3M% z@EiN&ZqS)!kOwxvb?z0cEtm{UTKEkYJ(Q7qaL9u`itAJrj20xQwD24I!oi?3>%cW& zOI)X#U`@efVA5ht;kZIMxYfmV(AROD8iFx`1eF&4XJ3?nj!zlk8t4HKXZS+QziwoulnUP=#v6x5+RNjM$8v|8ckcT=^ zH*JADCmB>;A-f~M;uJ`rF026Yy-&4bZSE^E`jU^ex3U1XdCtgTnlwW9;b0ip{lQc_UFl)46%p?lAnG?e_);L4@}#yukzZ< zoZ_sTAr{U+)=k^O4ycd50T~c?l0oGavJ`=JGsI#U$huSVP4opP8C2dB1&~74%@B)Y zAc5@)y-_DZ07BFc|8xWLx|K7Zbu+}G7)XA$E7~3PvQEaCmLdyOUaP<*!nzq^aSvqO zY*)+|s1N-D02v^clME^^=u-mL%@7*{AnRs-z!-)4IUYa;#GPbNd4()RVBHMWO+62d zFo$5A;=B$S?0(`@33;8$Qp!^g1bBdkIRy1X76AJLebt|v^q0Izb8nyGVS@TCQOqHb z18rd+tDR&}d2e59QVJeKupN0|hB*Z7fH@pMTd`hisTbP(RuO zKwCJ;;HQv&ZGNYa>C}ci08ziT2|J)Kpe^jSaFRjgO>NzzuvDuLPn$pf8{;?6z={LFE;e zJAx>o2GRyR+{Ijqc3_>f1;;EYvOwjv3Q`#KH~W{<_<*^>Nd}eIUY}E(bu%m_L_pS^l3!r`;3R{}>r}5j zk99LFErmd{J$)vvaiEJnVfPD^aojZNj6mhJmpR2*H^VYQ1XQnsb*?G{{L^XfR(XXi zMPS_w%L+A+z?(Q&=VFY2901f0aB2sC$*r43OuL1wn_)R21QKp1gVVgJ@-pofvTlau zg%D`=E9-_8*4pq-`}#qWj_siGf-WUs-3%)TF;KmZlMJv2=MQ@wDzClFDbBhXRum#2 zfj7~x-iJ@v=WfuX)E~$Tx|D!*Gpr=UKmxDhCWF&_q4F~A7P4-Jm4y&U;7v2^JFtep zcnN?Vu)m<6AWsGIs`Cg55(thN%m!&3tpAZ2Fd?P>hKByn#1c0`1lEF_Q?PcD)W;(SYZiEBX_C$X` zUqD;fZQ&$?$}22)1h{bxWILKSW_9ep&<^lT0Byms+n?+IRe9}YsfptO1^Yt^?AsV0 zP(Q{90BzwUgP-E>`vo2X0IFYbLVrMCKwH>t;Ut5~D=c>eb%h#8;CSOUU(hzBw}<4l z=Q+hWS22thA|UzcXHMfJ<_jkoR9>fg?Rl)5VT=?4SvUKa)A)e(tdk5Xuf0B}IO}GJ zhdF?(J0-us{=!KHmDj0Wdmig%s7oQxY)_v=0SS@vgR$D~7m~Er6NnR3Ugo=nteau1 z5CYZfL`t421N_rz?pAq)EJa}5481}PG;QkR^`ayX<0Rw&pnd@6Fcnl@wOmcJZiaC} z093EzBm?Adnm1KmwN5q7x*66J0-)Kie7s&!$-@|hwg9Bm4l1vo!~K_aGpsM9K=nFK zGC&TeIZNeruian5x*0Z*Y@lENTi>K9CVB7)``j(b6#Bz0UeKikteas&AqJ*K2DF3I ze4+BDR6ojCH^Z)NM<3P_G`+ED@CYtqv6%n_38D-G6ygAcCkXQVrBbP(ht1QH++@)0tQGBhaY5TfxQJmLg& z2=F0f9A)g#2pLB{IsoVqGA>c;t_nH;5HtW79C3s|0v!SdV;p5jgC2%rT%txA`7jX5 zczvW1hhZ3(sO3;-dzAejm@SY#WBNJ#L!bIbNc9heO&X0`)7e{DM{nK-R}u)q_b&RI zUGJ*xRX8V&yNzL_5bB&7y-NN!K6Pru?^;T^qogmk;Fj3+}<{Rmo z0zpu5=KsgudB8R8ynnnX;$Dbb1l$Yv9yB625L{pPK-_z8K`Aa26&He{qN1oEZp8sY z+#B~6_r`&K-SeMI@}$W%SK3nS-|w$|z2I`6T%Wt#<=yA*a!L4{*j^zzsn8$(acoj7 z`C;uMj0NcjAeX8Ng}=))w?dt+DY-C){T>T+=yLRVp=5Gl@`j!V$`Vx=sw|Fss~*|6 zSFCYv9x}`oDnrJq%y#tC9{Ch5%&~j$#}3=8m}6hh)C1_Sjdb)y$Jah>kum0jDg-{- zx9yo^$66(=P^{gfR2C{}?NmI6JsYCKwW@YR~J8(%fZd(SkSZMrosBF126#f@7 zQlWRpF_ATqhZ(BW9~F9coJe1T-g*(U^j?JcUg)%w7wz%m;3ZF?qZ&ycD06b0RXHi}zQRf$5STN|Zfjjs~LQOL%@CKJk$ z7y9A2t*~ke(n6C%lj2PeaoGRYl7|rn#}DMu{M+ML@@#8P$YxyfaGwX+$M3qC>9*58 zB~&vk$b$V)?RYaGpSOoU%aG6eA0cn$t6NoB+T;jB{ttB62J&or1|#y&hb2zMZldc{e^CYJ}n_L>l^_pL;p->cqZ}6V?i{DVcxJ&j@|`U+ly9yl(HcOqg zIP+`T1LevL2P@tRcr0{+z_)RYqfh{GphH|t9{4=&JLo4}_)FkUHgqycwZCngmoWo7 z^;PKBfjEIGbiCl(&^GiuVH@Z~ZZzVH>0Ob9L z$9b8U2~107k~DMHOqmqfEi4pSvuDp{kv)6nELpQ!S!T$f$Y5!i(JDiR%vM>lWXzT& zi&e%fSuC<;%(#%L#~cyEva%C8WBE#*cx%kfVWTc|+I?=+aIe|xvM)S1>~N2=dA#Q& z9{*W&RGy+`D*y7n>bE;(zSp~w+h*h%{rZko{~@j+#masCn)7V`CtoI0CBEfewk7^S zip8V2$=mNH4vn0?t@TyEn>osEEnav0V5?<4I&Sr86KQ?eO0n%);{xx%If=T01yW5U8Y``?Wn zvM?Z{d$HsGr#f8;{&l`ll?Q8v?RcX&@7&gZW_a)4uXv?Y< zTSfiMEmv9$2pRZa`I%xn0!-b@cFo(~sU~@!gYl-Lo<3VrqJ;NR;b*Db^d)_!wFnpD z{OVc?ofhcR{K=q9uA6dEphG4nlqJsF8|n z%&~_z+}d~rbL>Z7S|7^B96LK5^?Ez~lc^J=7i8+Bf2SR+jyeeWXWRBy{0c4a;`Q@w#l=Ghd{x^=!#bM={%Mn9tq1QQn&+S;|p};%Fay^`Tgju)%bl5nT7zEV%!FR(<<3laAHDvV2`Th~U?yaV{IP%hNsSJ|C_OI0)DvHV zL01)S&5F-`v)W7L!#sx*v)jDlFTq?=o;q@A@8Ex~E1{a<9s}kp><8`xg6A(M^Y>^) zFlQMe@AI~&RQYaW>2Y5_{in%OWXzZ`gM|fx=tYAT{S@m(lpXpuo%Z1e=B_|^a^$6pn*QcZ}g&S zhC1|$XC_pkS3ENzOJ9+l-b*y-OVb5V=$?ORm80Lh9w(HukCnOBYtb&{hGy+rl)M|K zglgySB0wc!KW}*2b~aRb_NknkO5x+xul}OlnKKUPE8OkJf0{nt?|B^Ta7sayhI6lTiukuJp42~0_q+W*`I`Mr3??JFGvhc4o!?VJ;Y)E-%6f6dd)a<&}+~u;?colEkPNT{YlV@M}rIm5X+ZSM<)Z@yFBZR3=>Y}+$mtWqLljH33Fnk;cBM8tir z=ETNPh~m&%D3lxPy?>MctT>Hi8=4qzdWggRznwh1w`t$mHxJF!g#Fz!jVLB$$AFI> zAIWN5@=C;S^e>U+igMSF4QnGxU1KQVKAy?fMlJogU5NAd1W>Ra?jZsl;sHa79C~?r zs`K|M$EY&fkI*%T`~H^~{V?M^_A*Rq|ErdYIn1#qGspgeIrg&5vDaXZUA&EYn2-i~ zo3AEL4^YI-sC#hYL0?qaDqXhinS^Wh_l!~4G+x8f8Gslj|gKb0`qyh4_<$Esf4N)T6#xwO$f~f~Y9&97pAPtaLqfX#kpxT%7K2J;@^fqTRy|0qY z+4mn_dSJoNZQ31bGgbkF;j}>y6X~!Ge&^>rZBt0{LD*dUH;M;mbfugE6F%dOd<3z#XV27jb>Q3P2P#_CS^Y=t};^Jwr7$Y zdw-;;0?lcnWtM31iP&JIN@4H9+Ege;G5aj}ov1JT zg5UlwS`7FUyWO(Y%GlfJcFP@n+C0nxHpTdveSA(YA43fs9M$ex-a!<L2wF&p_ z??>ZRSe7^7xXJnLK;^hyO?D|h^d29br!>;7Gcf;9ZJ~RU6)PqxFaOc{#Onv@`NA{% z^4XPLDO4!*f%+urBs;jSZ++(8@_P=kKI^nNysY-q`;BMk9^&yRau<7JskA-|x($y0 zqxFf`57g(HhdHl}UG7e?l_{!El1{RN>-yH`%uz{R#QL1nGuPSDHGWbv3l}=${e65W zDy+0V-`E$L^GE9wuOFyS)wKZwJT8}@P!Z7w&QFp~vV-gT*5`mBJrjxb*{^@|H|>VI zHlKgdvvIXMg}b4GO6#-Q#mn>mXnp!%^;RI`%gvs_<0+E9BkAh1o@F(EZ%I0CN8kGV zoWHv*u|DU0Ei`Fs7OR$i$^D{UwTnC{)F;|te?QkQczyMc)F-LlVpJnkaIX^t9IJgOevl5bJYoK-be}a%Z3-Pgh=)aoi(2&H6l(2;v0tRiff*I|U(&44$g)ej%hhKc zWA{Jdyu$qj@JrJ1`T;w*p8|a~)=xn7Idbus@b-JgQC}2YJMU;ek$SxKt;Mc)lc}M$ z*Y@UKG=++OvS)jif-1KExhibbL%cqPE_~0}1u^-~gf>&1o7$n+mEmhqeJUQr9)BlS zg%kOuwx|owj}a883-2JaT(`lPE}5$TbFoEa?M&69$8UL(&)#}G>cVg2n}L~o)%Fn{ zSD}(mCG5v{^XWDA<2oK^?Vz&dMO$eam_WmkP5_erCr=DC#Q5^{Tvzdlfeu{!8Ry>0 z<0sR+wfQD1@s(-6Lwt&S*NWu$)~Z?Swaq*xUH3hc1COH&xQ|9tzz!@le!3o=vwK&Y ze8F|G=fUeq|2}@CXv1WAD8OdnlXKidak@hhnBlKGzs(;k8-quw=^BDL6c$!|tB68z z4WrR>NhC5K$KKy6d0OVPX%bf9{k@<4hO%Q@Ym_^BRF&eN;eI*(zc7f(BlAhE!AScB zUBwv{;%pSvK-w9EA7OlO1cL>VPGXa!<977I*K z%+)`z)r)he>}m#|6n0xA$KY%e_(5^4indd02-1E*S8>LKI2$z%gWw182_ImSq~lD1 z9g>dQ(U-yUM=PwAFbMU_BG8Gl&soVQeHes{B%!D&_yS0F3lUK|L6h6i!r-^rKP#Jx z!5Vy79rw@s*}PTbY;OLy-`)u8l_3o2R*K)uQc$#&(}JBILBEx(UyL16Ws)3|rs$iZ z^2vNsYZ%ggL054`g*Y2E4wEo=dw1hu)7kbTC@v@F$#wiB1xY6j_DDKzM_(pwt9IQh zVUl-8ExdZ>t@v#KRdD(4vIaAW3d4P*Rm^I#eovha3IG)9$zEGzN$j}eP$96DAB9oQl1 zxE*~tyxe0`Lm3WfIIF`4C!IH#LmhmfkP(-m?tDQ3wTD_bT(GcyfT=hXeBt07^VXhl z$nKV~>1}?WK%0K(Xw<$i>goRCatxZsh&nL{KCEyz_xPap>cs`%3rTwQQ+*Y)kE$=8 zgB_BN+tHW7vz;?NkztTpd^upl?%d6(?*5Zc8O&f>d?6G-o-y57CC<|%?>OLVDh7oy zqLbsmn%i@Cq2~S!zBX&M+h%mM_-Ln+q>geHuXFW=pC^|k2TKOg{CA-qewc*4zBCVVE(GR zii;VXKlI@FM%kxR*H)Cz^sGoZ`jrdJNV^^?^!PV4c8J$y0`=v9{2J@ad8c!Yl!HLKj`DQ zAUJV&xq_=&uTnKAU%XarA0$frBBBlbp>}1v8No$57BzEe@S@`{{32qUGtdiQi;mC! zu-Mbd#g8KCBs;jSFPBw<8;ug5HDy+=ez|@DQ;v|@eRJCkrWM0m2OG>~7UpD<@|GfS zS&q+$Ny2Z&ci0^6}IfM|~1VTUF3ioSve*>`=qk=cYA<;waCwU+?eD`AhoJ zs3UnoeM_>Ik#*3=VdKT>oWG<=I>`>M>&s>4yuIp)xtzzjG1_J2r_FCGPo^I3f4;LWL zJ!d!{Nt1M(QLuyS`m)$ATlUN1Go>`=y6DG+r`(=iaSCPC?OI)fS=82dEid(v8Z6%C z3xLi}&5sdSoa(o~pUGKtIpZ_9=cxoY|F%urUT(dj6*^K)7Q^b_Y%9m2d45%=xg1#B zeee4y&r%utP;ffI+zd%~vN-+gb3XNaEZ8CGxE+02?C!Ws@|X;`#5de3scqo?PSmFC zLrxgXBI>Vl9~pLJ*Vw4jK>@&mG*qXP>Ud0xUu+ht{H_a&;0JXL#YG^kMHS{(Z!1TP zzB|jhY1q3AWjZQjcA+mz`m5-gqu?Kx?(DNuj>+-H?5m2)ueqIC#T&X`_@0W(Q;4%s z{$bX@{20 z-?wU^y4R}g`UV5Mk%cMD}!qJsbe&mL{tUyeX;vk%l|4IKC={MsOpNz!qmzz#{r z?dVIOU9K)A!~_biiSIVXJui?x>rjP^B;<(5lI^!bVo^GfWJ4_kP8$C*gQ*BC!xz@^ z!n5cq^zr&<0@AI1w^zX0a7Fji%W9Z0G}sY(davJ|sm(l%XQBXBI6k1` zxPcv#j@!`}!v=-#OYRA_8h>Mcp`5Z!Vc9))i<9WpkB~YoMKYH_Cj^=U%n){BJ&HYh)X((Vw(((Q!U`Wz&JNjbiF`GFoXi68-|lccGzWd4C^V*-59$mtNZd5|8#Vo*7rN>2*ty~no}>GOLq)M%$Ynq zVyp51sjku0g1>Y1X>h>I9nV`Vp!~7br=T~(R-f+byS{JXz6&XmPO^jR`eInTBDl*QDp~2p;%7FoATPM!f zzzX!t*kaS)Un)Fa?!JH`={TNX2iNt*@cM)I@nQ_SEIV2FS;zvaG{4p}vB2CM24k3& zITJ}3cH=YR&RR_j(|xgNoo24tO^)HFs;~2RdwikQz79?NvL6}2UeuRhSoh7xW~Rna zW08~8JEk^35Y~`#O)dNvbQPQf#$Q{yl=Fu4q0!Q{rJ(P?)|T$%ydh1}Np^5uUktZq zEL}~EA@8KK*8MqiUml79KM|C1R*gS}y8&KqiA1$q~3S?Mp% z8`2~l#}n+}y1p1rFMH;_7{kt-lcJOPRh^FAuSOY+p|(zGcd0kjz%bpHm1g?KvxCVo zoEti}%wcMc^X@@G-*&J2+*||0=e8x+r8|ZwSMn!SZ>J=G7wsW^U(i+D_k}ncML*wZ zzte)pgu+*R!jub1$5)Pm9g>dQ(HFx!9v39nDlSjj=6TK1kAelAiwk)jF&IPCDdj%W zDn=S)#3$ebbvh`3bU(z@=|GVWwOqN+`ftlix?rg5N>WHCE(mEwso)K7bP65m?dH@X zZsWZHJsW(?hrTT7l-9bxCf_(;|#_yEf*}H0OGS+y=?>xi!^_?$>bQi|L$0=#m_yi^IM+xSrh-2U7RNA zlwR9(DoGAQqdzWPF>!+Llf)ou;YjHyD$CM)2f_lDQFJ!D15YcKqM!|m1bki9bj~uW z{G8n@67s9>fVUpDsQ3JHL6rab;upV(?u;kdM<*lu}W5 z>xMqF`1pJZRZlUeV`If9EV_S8cwG8=r;}%2?riP8v2TFqwG1n{XGYg4oj6{u3a6Ww z0_w69ux`g<>)PiCp{%j~`-PbLAyqtriFzq)*bR0_I&NRzU$O?4bvuYpjBK^3S0Ni0 zQZx8R03E*d%-Y~zGWJ=g>}jg`%L5s~S!dRw z)X8!+;zyV4L!o*`pE^9IBs~v?FW4dJxE+0Q{CMF|lo-cRR~^2@^=R-;QTZ-! zTxBqhXqe4?H1UCqAO)Td3LxDNF-?20M;dCu@kEJ!7fp_1#}01KRetAM&ZzIzV^F=^ zt5NA?aU5#-ri&bofAj`U>14CUOr}y=_d-m?ZE3U_t_yMFKL}`u)8_mRr$eZ#B`Mn# z#RgGai4+RZmtvS+PMYU{x=kdVWCz#v#j$bOO#WgVRa?5nz1q5rT9&kCxm(u3v}K!x z#|_3&+vM{!J|nJTG_L{m#7sg*(wTRWs%saI8q8!`daO_Y@hPs}HUg6sHqNZ23zNX0 zuA#b+<z;Al(l!bvjVwLoI#Oe{(f(HaUm375eQeG~i>i1$kd2yT@1Ug^ohX zVa4IYWygws=9yGoW>VMiQ#YjkBuU5p8`vS~xE*~ttlz7*V{b5r zXspP6G`WF{AO)Td3LxDNF-?20M;dD3@M5yF$sXKXi7%z&=|@Fx&)#0H>6$ldGXA!` zRSW5CZ(a)Ht1E8`$T>wbj5>8r!TI5XIOuGWbQ~_QL(*|O`ofskuHr{==hVgVApPXR z0t&`xuXeQ`ZZM4OggkrRX~F{;@uwvpsMA3Kr28SJP6vv7s0GFuV-u^J$|(vkuJg0J zQafO33)PPs-s?_WIf{-#2FBN0LS$dLWxmF!6N~^I4iStLNjmNU!465s?dS`m+qiD! z#4y4D4jj|kdr?X00wZK3g-8t<6hOKkV(N6D$cI{B%Y7~t})i^ReQnXN>!WB zzUf`;_vo0G=qO|_YE-fRJx9(rnsL+#NAPJRj7T~@K?8P3I&Mc_9RKSf8A&)2VV2$#H~rVgM4BAORf|8?w>@Xod_m3*XMZJ3P~UBhU-Ccs zI^!id9L@8nI^jr~cLBWc`54ggt|!9`$zaXi+`eX$rvm{#evIqq4bPraxUS03Io z7{|0+&wv6*XcZzNYz0kjLyLE8xYGHJsc;moXV|tX+xf=S*k+4IeJ}AN*G9GrD;+Y{ ztb0fH=?8z3Lyg-Wq}TpaYYgFrGOUFJUB&H4kCzy%<>qf_MK0-5NYJNkkFBuctvdxp z%gQaCq)9r-4zBCV;iV+EPGS!C^xfLQb^9{9)TG9F+tr**O^xkd-(U`NF-ONYnZ|9` zFA&P(ji#wWf#ES~%RlGTTI5IK-~$3pbRJbjTWoq#Mly4m%$BnozLs zc<1dOZ37>)JAE8|Ny=gE*yLb2e`ub%(aRskY?JZ^evhQzz?LwBKP2h69ep{BdEhQt z0tfz3<%+H=K2b(Tc{ekd!?gHAC;&P$H9tn+u$q;nw=Nv&dR-sVi3>}*#YLF9$y9x2 z%Eo1`&VH31KbhIk@(cR1%+w9_XhH@#7|qYd(+S28V~Z@g@qU%YGVpm<>-z7iLDuoH zAJ`%3X`Q->YcZpg*eM=w?{ueVV2H3h{93Ihj3zQ!UGuzN!Sf_x^$nqIlHLG zKvTi!z#p~amw@E?R0S8exm$-iI%VxR6zTlbjbcK^Wl?4V4ZghJ-R4Kw&mCbJE5d;& zd?h#N_{wjvL(*|O`np4f(<}!uft5bkJ*PaD2`j=U&wabrU;?#WR)mcBbCD0!1g86n z@Lx}dMwpzydLwI1-@01Wbk!E`y_+tLvJ?|oI>WJBas(Rn>6BqkrHY;2+2lX?HrR4K zA~Qv752H?Ci@-tm#}=Y4{1K4%^oZ3INhjICb$tmeaj(n~F@X)wc8MOjbTzesUxQsX z+@*!V1myF-qSS{7lbq} zwBr*w7Fg$%m{P*E>D=LkT74PxlL-5`%>$HIb+G8vf`JZR<=SBk}1f<}cls)c88s_b@qs z_x--T>f!g+B|NlC!{%2CMXLFW_&(^19DnAi7@ekKfHRz%xZrUk2JKm)F+~G9?&rV` zNyqK$%U|f2vbn|leai2B^kVK{VJc=t(%c3H`#){`K}ID0(%t{nT0j4nsrVD7Vru`) z{`5uJ25ws>D@XjCx9};d4Va4g-X_^R8LCLL2PBb0((wf{-~mZGZbx4N8%)Z7T1=qe znD})oCF-8YYA}IW1-vwSj6z028nhuwm);9!CU-7=-{b`TE_6Hl>h@)u&GHN`KdH^E z#;6W}!1YNnF>*d|gn108%NP*GdiYuvAc~~peM+!H(s4Wb66jnh<&l^`xJm#^RW1*S zG5on(X}KH$1wiMd=0`-T=1!5KWenJ*TcH!CB2aixRLa!-_NB^qXgU9RnJUpCi+8d` z_n&ZJK)R!s$}FhHnhAbNtsz&rsnx%*3`W!zXj9Nt+>Z2E9>Y(Y&@Zv&F`ysBmd703 zl@wKC)M}cflkDKSzUcM-KB0*iz0uR7T~7tCrYrHQQzoBTINo6Amxrle(kv*S5ydxw zMpLKz@|a>>SL?J)4Vwiu%JLWiy^l3JP|BQ3U4q)*Z`aE!=OeZ@zOV4znC|FZm|9_K z<%cmmN?a?b|7$K+GBSF6R_TEr@2%+NW2F!81HJs|zKYpL)hp8gNs>;ogX{XD*XF6k zNilla9-pqa{(2bQg?|Kk-(p)j8H^r!b}k7$J|l{21I?zc&liAiBP>YmR~M3N@p@Eg zZ=LS6PgnFB+!!#(YTYZBgw7q_2gPo1WXtV*t;fN1M-OU9K1{8C4c#w%PsQac#Mvl1 zSJM8xWl~2GI-Gb15_EhL1?-S?+>XBJb(tA+RE!>UIAP8)Xwb}!2BW9#>N{k_H39rr zHw6>`_DDl@I;oDww4j$|-NUjV=!GPo z&%Et!n8(aE{Z?Bpxl)fky6I&Pl#xTve5paFOAY_>t3GqoweH>b%Sal|pt=02Pm&(J zXW61JAI1pj!465s?dXf%qk4DjmnT{I-B%e?<7Z{d9jO5 z1OjQ-#}@3j=JODmuX066{$e{x$B6p(Y7_p$l3ibShD$ zO`jX=14+5XE{AeW=_<#c*#qjtA8>|q6U$$0C+WDS13M%gx1%qA$1?iX6!Qnyz`+5P zIi7iOy6^`X;k-Z`3IK6wXaxR(><%9?6@P*UyuYr&%aRR8HJQ7@v+&)72esurJu!^=fkTl zd5(?&2=tAAvRjTo^Tl?Zd?1Y8LMCOin)s_94W|bXMbhy;CD z&Xn)xH@I4A7#&k8A-}-{rezce1%Qf^hDIQ8vtQnFrXoCnX)3^f5Uq1Q^F1GjJZu+CUbiC57!Yj2i1AX5Ok4nLB)e|kp_>1i% zon!~s^+j)fwk2Q1&TkBVvHgC#2S1wBcBQs1?KsI`^w3)i`6knN76qRX#hz@;`Uh## zDirtIas}Y_tEBzv402E@FSL(e?( zqLbI_#@}y?kIcY}k#xKt33f<2Zbx7AzPiWs6Qfs!zs(2+UfHVb+hZ_#)&en_s6a+S z5_UtK4hkUM4>5H*P~<}`{mxr!TJF#VJzZ}vf^_17q{z zb%I`aoODKXK7Y3@NhjICb$$7Z7<5DO%B6bzO|X~l)*n%@#WcEhzgcPH4{Ndnu4xns zWh!^u9^wlC>7}7Y(@J*>F)jQ(s+`A=7mXYDZrio@vyXTF=-4zc?_SqwcPsZp1!u>7 zEQHM6wioMMJtBvpc>+`~H+TcP00C~0q~mT4+#pHE?dXf)y?Mvph}~dC-VMV1|LJFy z`Wfs7(Q;4jqlpb<1S#-zPyp$Eh-un`J+48|>6a`!^9INfXr6x2i9jF?pEiN%7m|*X26jj~Zbx4NtrMa%hzW%07XYBr zx6nK3LLg*>69aK50K}!C5eOW4twmo`5hzT*)cu%y{nipsnyR|wt(3R_UGANP1rxg0 zFg1D_V{+*jJ+=B5?rD%V+aI~t;Ul;Hg|3KQO8|W?w$25nWk@>74zBBq-lOFGKgH-} z=NDWz9~y9}YIav@SmxNf2BT-gR6MB<%4bAzZKFB;(q;%(0Ico!XlhLl-_qjz@^0*M zR2THpb^7IY;GxTo5j~ybE1#NwIWdzhTkiQGLyF6xXYP0E^+=KGQv{m!_~q~TnE zRi7mNaPQ;G@*kZgqz5}B9k-(|dgEOtNuGuc&Zt<1zKOka`_o@5%r(t|YbXFzoHR57 zdP}Di?4=8OFs-6%C@v^z`bFq>Htsy;UYTs)TgIGndcEUSQFeY9`kgZ#{Cii9K=TBs zP6PsJC7vh;`JI?95CzYTAn7wVF8o18YNpVZnky)P zbU(z@=|GVWwRAocR(H>8au3*S#ijcbS35Kfc)a4nxrsg%&{2Q~JhP>WgPA~sm!5&= zB9TMV7q6YOy{GeR8cry%L(*|O`Vx3P-^h|;0>J~mqRKvvo}RFoE1}IXVUOqO4Bvsh^wkp-m4D{w7?ECjUG>e8a<^;d=jHHw7;JUu( zWjnvFn;5-u{L(X@C!OpEGfU<+ed#vFVCSdpVH2r6=Vc{d0H`2oXaw|fwR)XF7xdC~ z?sIqHv3-|i^>+(6U%uRc?LB9(NBL_=&W3X6nP*;f@_O)OYJ6k{UW}yU{YbDw(s4Wb zqBpc!zUN}};K9={@XGqKui^bpZP(l(BN9?j0O@{+838@(_}a&HK~L8?Pe=zvL?LPJ zlkHzJ`yGen&bDx&%^mm1&g*6!7~icD`V!Y$pHu5iPC5R}OV4!T50;qq#(JHgSI1^V zVd)u3C)vSuefe`bwBxOqKUjJe|FmYpcIyT7)L1t=gIyouk965DwHG~X;R}GyNX?HC z_^W-SQ6^pZ!(5+nm!2JR?BhBj=LC->i?U9(yV7zyI#PDr$3n;~J#)+zdq@sL^8~0) z7=rsE4cbUL?$*E#NyqKzi{Y@_d76tcgclLP{C~pp!JYsPS?2cp3J?8P8jK#g{fN{DP3>8q z!}$ULY|_vO=q1|QIqHHQ)(182V|I7tTlr|;oz3pMPfWI-)u2><_9*>NdABn)dP-@1 zV!UU4P8+bl-s{sUn#)O{0Ix^V@rwxH^+-ByM_=^Ttr#u) zuG?tWBK|XirqK(#E0YaIPg}n;HLnK+fQplb(k7Gc6UVglJ5}CCX6b^SuKi6&C(fSK z?-ab=gnsc8=lsgiI52ka@=b%M*JQtZ?psKL9D09r=0$uMn%k+>KWV?9t2moNoQ)a> zz4EUnlo|75EroX!#})HmbAKgS$7eXf4oS!D>xX8&zWd}}ON?P$ zq3QvaS65On>?-OLa^GMKwLR?`GLqt>#tRA{-48K!I#A?8Ef}6Wp3~ms7b?9c1#kHBH#Ik1FocYx_^9zpcWB*jOK7ZgCcA7bispvZ?>FdQ3P?3k%A6g;3?@4~i&vrKf}H|O@ITeD~u zLq(qXGt>XIEBk`Ve(zAD!2v?O{lym`?#2#`&eT1e&X2AC1l<)||G9W>m+H%6!)cOE zvV-gTqW7Tbkr!h02K`I>4oM8B$MefC&p#Y(_{+w$U4R(KWkhjJuX*o#y08DtdZ?04 zuX#_`3lL{Y?ur>yBBAN}WxWo*8tR*st&Kgk;$`3PZeIVXlh;e)(9;;-ffvKaYoOzu zNw7oGaXb2=S2^@qiWt3loj$H@^-q{E?yI}7pvqvc$6m)_&n8VT1sQSZ!GCqSbRYNi zDLk>Gsl1*Yf4q*_#&~~vy6Z{nxpbx2;N4eUkj}0DoHlY{1-V|QQTa>7^(pxaw}0WI z2c5kVdUoj+PW8jqe}Y~MTmSi~%JwJ82f`_mPO^jR`tsLk*P6{@{?3LJtdVdooI1oW zzjQwOA|g%vk*>Wb@)>bwqVSYScIg$;(tZ7Bz_WV?bm0$keMVXTDe&i*WSzZCNTp^` z6Nb3-DOq?WI&zM`y3Pfv$nj^Me9_DQkw$AI9rtJ8|42G+M_>M`jC|Zi%wGWS|6uk% z>)mq04dzeV1Lq+lbjGPaYX1iXQ126Osndy7&225CzE3kw57dP}xUjBkC@uu)0=zK! z@~O?D%#VEon)>G|pK^0Z*G1^dlF64*SH|Cz!_YkWq7#PDt;8{b$rqB2;|6v}I&Mc_ z3=<N$xgp(*;AwNPO1*(bb<5rj|3=n^%O%mt$|Nyfa$mbf12`UH$;ff&RslFBQ0TFtjhW`V;i6*y>N1lp*OPJGibddYg7VA0tL@ zPss~kZwwEoTkwl77xirU%wY7iz4u`^ml4IGr#bnO?yEojoc8Oq4hHLi8fEpT-~sDa zINjy8@1@prSKqd;cs=`LR2vcxX!m1iYdH+f9#Ah2h_BQH4@lDS%L(8CNjh#vUkr;Z zT-`~GAvh*jh*`zct+>G$YU_wXMjVFlU){lk0>B<=s7@!<@tBs5XmS&)nx^WA3LbD# z#KI}xM^y7zn|%E1^?;}2+465K9COdq=>5eW@C$$c!^FhR=Yl*J&~Q$GzH!0xJ#P2s z3%VEoxC)X^vV-gTqL=N8Q)MxFx%m4ZiUJp4=A8FJmMckkKse8xM!7Hei@L5y$4>AuU}j?Q=_Mp);AtYt^P^- z1zp8i6yj{uIE%31zJ=#)N{13)c*(}5x%YVmp-8$<`{f}XC^E|5-K5YqIE zfS!G5ts+lzRBS%;VAP-tiaL|nFE3p)$mA#gDo02L<< zjes6C^}{t?&`VdZmvzh8JSg|FSFM(_+g*mt!85#PPprj zq({%%J9@Fn&@(^iMW<;Nct8t| z2B1XJam2t5NyqKzi(c2hXETY>gXgcnnLj7PwC(AF9%LjwQ^gk=pa9bS5HkXLSDW@S z+4VjL{x}>oYipm=s6qP<(_1D7wPbv-5Td-nf`{qzjwt;N&aPQhVZAHogG- zxrzlwAaMWO`KEv3+0G8vFWuPU(PD>1&d=0M|9{b8N}hNYHNLUztNx6-@C>V5ESg$f z8@gZko{Gy*h_g}S%)F2s7&t=Qv4L)b4GX~zNyqKzi{YqldmO|V!t*!}eH>7@!9R=W zo>T8tNE3!~Rg5&qh}#eU)lC5ffIZSsoldIbF)cGM4Td{ZFjXJajxVRikQ=Iebrbwq(De8v*SfFvF7Sb`mrj@!|fzkaVb*o*mt zG2p{tEiyigTtL66)3LX~{As)02r`lqqvi?IAN9NRXGC9!#}-zAl_{RqDVSU6!<`rj@!|fK(CxhpTq=$ zYl3OWvdw-kOcw$nBPls*vY-Ic{SZ^914Ta6LSV({8U0N~pdDXY$JGnMN6j5}#BF*05Is_&SQBUZ3S8M5W_M>*&BC(%<%>l=@yR{x~^g0A8$3UM}SoNEu@wBF{Oy=ShI z8ZqchlJrg(l3<6V<975#Z>mF*?7JQ;{pxn_R5FMjb>P(}gV96Jd*MFPDn=T3Sv~M1=G+Vp!+Y#^~A1$TJOWJ`XuQjJGibddKDj@^ON&> zhjZD~pS^S;{i;@_s|KT2fH`VIz20fQ08nw#&^-EP;dW~kn zbs=u+=+geX!&laxar&JO{L-_YSU(c<6BwCu_@!qgon!~s^(FAc@u*5-=LbvA=3jK3 zIIMRlUDw}toWTTYyU{PTrDrqw0&q=<|JP_*JOLlqLSW%Z3Tp$LpHUvRB;4vg&$Z`o zx1<^^A|D?;;FsxcVN`6EKz8PndF6v!+3>=07@Ds==;a7;2L_Iiq%Xkwrr-!kI&Mc_ z4A1Vo7AM9KR)jU|ndE!iE0`YcT;4WK7;-#lVgniRyzqfK9TY&iA7bispvZ?>Fs!}& zab{gGgkhbop|~KV;h!C!$kDHD)#*=~STK&Ru&rKVQ{Zj=w)S{qh%& z0bxvcV8W_SufAxG_1fKtZF!=eT0gTZDXPS%)ig;b*}-*v`Kyr8^^KUn3DcupPX({0 z13MjBQ-!(xsAisk$p-U>USEgxToU**PcfRyh~na!PkdR*7XZ>rLnH9_ddT84y6~5- zW57Or@|^Fm`CpfXar?^^-4$rh9%YT1)7F|AJ*Bk1@mOm0Puef&D$b%1XQRgHfr5*} zXDngnlceKgIZX7K zNcTfboemWFP>bt3^>hCZUC`6j z{7Ki^uDC-+;xkoz=N}Y6x*uXjK(EO!hgYUT&w)P<$3sO51^?{5#AC(pYq_&E46BNC zn0~3?HpRzGV47Eb;^Q({^-0okqEaIkx1%qCDL?Hb1j1rW7~u_aJhKZ@Rx0B zBQP}|2n7(I(CTd?5Lhswu$QTPpdEiCj%^M&jdYyWto8KmRdU8gX8DM8Zsx`2-}SxZ z_%ruGb>a_(Z6t0;I_?3%4oS!D=*!==6LH7I{K2RU98lP_<97}AfN2^2K>^gviMNcv zpKsRYrtgDZ$kO@Nfu~vAgV$RPZLn$Hbaag10gug}uv3n}KRNfQ6j!?Dc52N)+AruT z&ZZD&qsEzlA$dCJgW{eGbet%#L(*|O`V!b{*#X%*kH7)dJasS8U;@!o&$y4YijkID z9~26}8^8ihdsqTKs-+KFaNUv8rt*No1kAU>wlA&~3~<{Y_G^a2<=otDw>^LCEpA57 z;NjmVZs{3?JFUR0b^UkMSVh$Fi59R!(sBFxqL-&`Q#Y~mJK5gpPSL;+3g$m@J~(mI zVD!+{ckZK!3S3)c5+JimPPz!q7evQcwWteu$~lfg&GjL9fuSaj#8Lu;RMUH^Gf%{u)DPDV!o{mv_eBID!;G|#-~L?Dn>yl28ZhYQPTI6A7y8EY_s+U|IVjG$t;P)!yTK)N4d>U5yU zhgt~CbadZuQxRy#m)5b-k(o0d?XJIK#Pt z@f}IWJssE~>9`$z`J3%gb%2;Z7>@*rje0&UkW?q(_i zg}G1n=bdX!dYq^6#s{kkZ47J4K665`cx+S;Ip_B$(fbc9xh^s*Z^61b)Xof+V()xf zC3`*(^+XFSxhCl(JGibddQUn&Eh0v562Ij7RlizZ-W!+F3q}=QV6gK;_x_=)I10tZ zI5tqEBygc3)g{*-_yRzBX=nuWDjs`SP#5&lb;)(Fi7%!t+U?eQkK4(Zl@=xcVUMz_ zWtAy%=$U6;bn<#|mk>TO120C>@qQ%OA?dgsebL*U;cIO%dT@XXT!7Xt3$H`m5vy-v`}U^Aj{(=ACS*}-*v`P<&kd!CrTTKxMSUftVY zXaBg>^hU+xGilGm;S0RBwH0weG@?q~nXy6}g&KI7hWn=|i)tR-@dYC3OA z%Xbx@SKWjTlO6Z55HdI2zV@1KA%~%P0#qjq!F`biZ6qCcYhZ_@<977L@IhknSz-*~ zp%5_tfAhzc6$WFd?M<7Ik(4hrUQht(eu$~lfg&GjnE?G>xyL(QFa-CeYbY)V$qfqA zFAi0Eu8Fzp+iKml-D{2nhdx1HhUph&SFg!(1pdh}pi+D^n%k*018KjYt2moNoQ;0aLZaN>l(^b1MHNdr419k-(|f!|}t{ty!g(=PykTj3S=(uF|Ch-(7) zuWkw`0PK;5>U2^ak7*&WO8xSeOhuqD{ZeS_*1js6Ax&4!&EMgNZQnU;`MaN(zf}%B z^B7Ps=XU^`W&xB)dI@a02Am&B$L;8gp68^O-eUA%Xm+8){T+9!t)vgc-S#sWJ#CL( zf{diFsF8vKNcTfboemWFPz!ofd?MGG3Ozf%w2n_E1V;rHzSv|_yRsSQEKbgfbZ!i| zX1M#r)UY zUrE++p1=-C$L;IO-{G6|0x^H3_T>vMAGC@Z5c4Zy|L7I;ywWd+8_b`!`;H(ZXiU5* zpa9bS5R*0;sG6Y`{x&Rj`NvfJ2@hVXJEQ3SgyN-JEq>nh+w0p;XP_gn`rVy}kQoCW zvzYnVjG@6jP{8fw#-ab7Ok7UG8FI)yxJau;YblbBV+D3dI&Mc_410Vnd0vcRT%qa# zmRDC&zYExg2JH%^Ro8~@G#Eo|V?f9VDuxTyctHWA`yr-I2a0^C1;fviH{CZmhK|*! zZocJixNf7A4O*TI;%zN5dZU0Fj!(`h5kav@Yc#wh=(yJdJ0u;q zuP=r(5A_=)#<2aQHdF8AUnzJ)`}ghlrVECUkrW>_Ug_=)k5ww_Xetbaf#Bh~@4n6P z+2j%OtKS>vN)|8K+NfB+OBOlw%pFmk&;!p!LWZQ{13s`r(s4WbqIbA`jFlKYa7^d< zf#A2wwuV1?P}?$W$cTg<6hOKkVroP|kq@|&Qj zW@yp`9fhPLnv(CV$=|)Al&@P*Q)>&-enD4pmV`JPHSTzDT9&!b*5y`rL;)+3j(03! zJV?@UJNjaHXQT5eF@`Wq3z^U$aKwk@bn)xMZy4+W(=r}}0zhL+Lur#q_laX#F#O%$ zrnRXs6g*&r<)IJG=MOsvch2Pf$i7HJw(L(6r-aIRz(3jf{EJtj-H#m@ovC{`{Wvjx z%DrqWX*eH1_oOf2NO0=N4U8*mO4W~&u$qugTi(Yq|r{Bfs4f&V$9g-MM$83Fg zyu^m3w9n`Q9}PxN+cU5Sav4!v#b`eKljaKm6(Hs zecV^Z?Mq)>&;!(T4aEmUx&&{>CvqHkv|jFu*R9=_9$$aYYiP%JNawCX6u(P-Fgbsy z2gt18<(x6I#mD1VS>~a3oX*rL`_cG)#C0KV{MSEFUI{(BbPK2EVZBb!KVZ|MAF6DB zl6)YXBIzVMxUMgMbv^UCiupSoQm{tCxp3-0xdCBbV^`C4>}*D)i9f8#61b*OC=&UM zxVZ49558#?itT&>AiXryXjC%4WXI=QiT%1u>q6z$YPPAG)ZSAKf8{d~4 z_4)Jo`>5a?f0G8}9VW-0dGbXs|3@0Fk#yXjf&U}vxE+1@o9;U|O3YsX@Bd)-fAQGM z4Grc`+e&Q6NI-?%P;&(ZknV?=IvptTp%(tS=CJ>&3xB%$JxC`m2+98mlP~qVty|)- z?5+Dj_imef*0yK6q>{;(HxY@li(&rc2v8|LB+c#A+JdxS&{dpGAqc4WNqrSw7F@(t%pdd@c=7Z^iA!HL+y+>tnBi~V)b{3;-CRZ#hm7XrOS<0%xGZ`6770(oMsCrc&g?XM{N$GNH9Z}C;Af<5Z=w&ot1_jt5>9~D#!oufE zgTost@0&wy+-*^4K=Vb^x=X!>Of410$JbIBnS^VtLOO|0Sjk*g%|)H66+h_fv1D7} z{Y~FL<2w48uWrsE_e+*;RamZ>-NTq0vuQXis6vu{sqo#-%pIvhdZuvhbZdZnvkra*wphVJf#J~PU_j~{nhzjp%#XMR-qh+OG{9%Mv93JM_I4>2R4=bmt?nW@lo;E%)6t#9$Z zo-f8Vj>>EQFfjX={z!-WP!Hyf3X>zysMGL6_V+(I_;#lQP_fcbxHj?^UIxptJhFes z7m?IutRD&bI?O5314CauZyrUFbdnuh*O$O?eKs@~JHMqDEb7N~i=qk*ypZ={`=#`? zEwPymCQ#e6h?esiaZN5XwQw0M8(#qFDFHDf5SXE7=32TCh)qHmTTIVTYoh`$0vCp!>Z_h^W-ozuLjY}5#kOE93e@!DYJZPkmDj6&Npy`BptV- zFNQW7R(gmrT*N!VLmvkeZt%|{I`BbN!>8f3-IEF#!GUt28ZRh-bU(z@=|GVWwG96{ zSS>Nx8b~|7w2m8I)be`x{Zi|V?=G~CsJi(V(z&bA-`;JjAjhA1`b8)HfHQpB1jc|Q z9q(9z9g>dQ(U-p$Bfm)agISS>!&+o~7`cGHd1L4)gWaIEo8cfMDK~1apa9bS5L2fE zMLyKRUynz<_v+#Xb)9yBbmD@fI{k7sv*O~hdE1@iM_;jjp&GQ6{c=Q~eiutU;uJNokXY?q(pvCuFo z0|&IMZ8m3vJz!dfe^3AtSMoZpYT@tqgbS9Y;!o&Ae_|Z?6>PWrrHRJ~yo?B%oDh?0V2Ntu2eY7)(l5j^0IC)a=KLLhb>!YGR&h4nACaX*@58q?S{{Nb$~%flwH ziy;+$VbT5m>*%StHcb!odfEI4`?({G9*dy|dJYV|Q@fI)N{m`flXQ|DT-O)9I|Yw@ z5u-POe;r96f93}yW$k7#dgxA6^h;*Q>qycaz3z(-6*W0}bAYi+%lV_jRNK zF0+-j{nz+za_Id)jmvz{+GD6#+wIB{WUE)8|uqKGo7q=x|D9j$?!i#dB1m3k?F_Y30L29+-zKeI`@vhM62=Br-E;C zp|C#{T}a1%P2%;Smn}Z3`&X{FYWCuC-h?NLJku>oq(ptJFdH3}6I!9neDd%i7i0fR zb5QS4zZeHJwq{<}@LBt~8TDc3sLV-cJgKNs76Gl>_oH6g<$5u}V+e(+yEb=9E5rpW zoOhdN+w52JCj83pEA$nAl)3877dK$IWO(n=uua&bgX^v@5g6*TD<*iO)z}C{nY=^Jyi`n$~j< z&NT?(oP!YAhYFA$Xo~Xaysjhb9f+jx<|Q?|BC%)T4B{H7{=mUc9JhUw&27%=vIi90 z&%?n7-Lo0~L;_Uh+=q0c!+r>jpRPye?B3NTUvORQdGLDDzmFd&+Aw(?3b0xD&xD^T!*8uJZvc%s# zRf!5e$W5}Xp)Wa%tZMLhKyukGvmHV&eff z?v^>)1se~vZocEvp`WK=_>}{r-b4F3cj;aXSw{JV2Tkf}>V(8yf9{ z>v){~n%NIHo*zi$mm|4JW=>L+br#tS40l;e-NF38G=2f$F3b=3@%m284}iV{ z_XFi_T)QDY{nO+Jpj6Uam}yeJR4pY(NA?5dypkv5h59S}fc$}`C^y;8zU#MQ6NNV~ zso53nhIjfbt^wQ+(C^CFPD<`YEBtGp?EkD!qsS`vBMkNf?2IdWQfvG!D1?lJlOAno zrjzUzBD$v|`hohs%a7~f2Y$ovd}^UkMrI?`d7*8G+ANOsDC#k72HpMkj9w9$H>z;7mzgjQ;?asQUz0|tmw&i0R@efX#`~Z|nnu|gK`Z&qa zk^R7=2_ro5Lj4tfK>k2el(C#2&}d##vnvMgn=4rsjQfG5DXbr$dUf3N#UgPHJ?Y1% z_6GX_^#w7_-)({)5XKE&d;#QsrS$O^L_hE~YoibY{6MPX0&#&;ofrBPb}umIfuH-V zI>(kYpSp(m^=CfkhM%{Q^8>BpcAeNC^|_gk`Z_Te$Np=!mo$N) z`-ShRID0~zjY`G?r}!MjM@71rxQI`i2lYH)T_J5ZGqC@}r8K`!0k?aS^v`sO3)HhpW4xKnm4{V;iB z!E`|jGJ*r=LUmO`0i^pOrcMWne5hrp?SH_=&H%Jh?P`e&l4=*r=kVcGj(N^`ENh%E z`qb;*D)!4;qMGkCqh&B!aFa{9g#Mv(>jcx#Ah7hFq~pku?C6SCd^cOk+eQaE1!U{x zG>J}m5EnMG)CBr?>~zClaiK1RCJK-d95@%M(?J2G`yr-I2a0^C1+Bv8!}FLNt%iet zeDiMcxb?jI9fOX%ecg>citb+1N6Mk~Us}_v;@T@c78Y*iFLA#7S$^l$Js~uglR^Rd zG|%Q6wtrG1*OOnWiXl=N;`QQjfR3wb=D;GBwop+TPrY zrclvO_H55mP{n$+QmZo#7k8oS@N0VGlRUl`YP*OYRqJG9gS}corZ8LwXBJ-9CD9oftj1 zp`}sff{i;B3!%$zE?dlC^wa|aO;jKwzS8(Woel~h-48K!I#A?8EnaUyV$+(spqJVl z9ll>&5K@QIfluUkclnfFwaV6S9CNHp@aG4g4kI0IXi4;@x62V|zNM2iWRnmGq~ZNU z=vR_-oG7qE(s4Wb5?E&OtWshE;ZDn|fwgK??-5Mf{p)(pU;^_BXQL)Dkdcst-B724 z0!a5mOq~uC`A`di2RlxGZz=-q_|iJIj0()@?wz~!vW$&_GM>-P&fIagbOx6>J5`Q9 zvj^0PKi~}KhBQtC9rtu#hos~7_2n=2md7SBfAFjUa6pUChm1-W{vabMH)^h+0Mh*s zQ>Oz(KGecr&1JW}O~s$!0dp+)cFAqaHunYZ+a%2Rr&CdM6yO0Hbf_cyhC?%fIuQt- zi$o4d|AGw{!465s?dVHjyM*&K#RP(5ia7Vh-RE`)efWEY(*_f$?WStTNJ@^HEGU3< zKg87OK#>o%5E$Xo(#hlm?ydf|!m_(Bo5l4ho1?l<+xzG!fWSp}Z#c>Mz&|+wqm-{! zP*ZCL(tbf#ah8NQ8$}~jw)2FpF{XJGh+hT(qDVU4r-V@;NyqKzOW?wH4@-&(gu&Uc zxBryS8Mc(3_wD*%g9%K_C=d$3H4*+_+GO}%bzBR99|}>Xf4S37l~vUnlg2e&e(~0) z(AbCE1Wen9y&- zWH5T@`Hn9|6FsDPO^jR`tp}@C06o8pCJBm<3VeD>;1A_L1(PhA}me(VNI66 zHH|`%+H=ik@dbeN(omymrMrcg7XD^<9c-ryf7rDL;fgv*7xHE{E^EBI1uQwr`?R>Hj=Cn}cJ<(D2wN~aapk8i})N>^1xLX4^ zNYZgT`eL|nsoO&FNdoWPfJw-;?fXwO7(?`I5$>aj4P*o<@O1yj-c`UyaeV&^R#GfT zaR~wXD{>G|fIu#e2A8(jkz61pMhu5Qi@UqKlMq~T6^fTaafd>&0)ZAQ6#g^2`}St% zc1|`)@85pz_>kFoGxJ8j^WHclKNCQ4BI?cyg1V*HF zc|;-*#()5TPg6W==LrHKBC^4fyD=dFQg^WB0s;q3DEE!65GY=(RiR`4L$wdMgwOH6 zT%)GbfHqwIYJT4+#16e2Prqc}{5G}nUo-X4W&nCDIz62N&|}eQKGs5S=IvRMJM91w z1=}W8xqp3@e)hiETWtb8NB|U^)XW9w{ngp4uFaw6QE+tw{}#HyRg)a+j~oB69hb|9 zkx5VFp!ZL1m=?zh(sBozx$-wY`NxM8>1l$UeW6NDcXjINX%k^Jk4dN37=%?pBmV`U z5U^=t!*su!J9d*&P1tOyS@L{D(P#WjC1~HTosI6onnT-LnX9JB=CUcTL}F^4x>38V|hA@9Na}^*v;3X!%14Qf3-&XO=(9 zou-R+=3PaKp#{>2h89RQ7M+F`i;tzyid#0_iG)_G>D5#InzC1fRsr{0o{FKx-BrQW zh1gqhHv9)75((Ug!C#(3tLdSZ5mrD8AO$AOpnx6B4`hb&J7|5eoh)HIb0R8?cem&J zf0;KL>Gx!6FylFzJm2diyMVBC(n;oIu z$%L?GOR5Q;)a{S@{XM9oOY2!N)gES*E;Jp}`9*_z*)QtL;mGxv|fJiepxo1e$@^5u;?^@Yw@>w*%((6f9;FaELA0Vqo!1YF^}ff zouZFuHtu7^_%pR<6C#3w;Y|asAOTW$uo?UTMcy=lzpbN-Ke0mefv7WUk_lnqPZWJM zZ*Qw!{@%T2JHDAYRE}yp^c2sP0A%PFY5;mHI{l&s@L|zuKGs5SS?B5{ z<)8--(EJf~;HgcZ2MHisvf(=ypy&AeF5AzQY*49(4Y)Zhc=i`Z@7)wQ&4*$Z`n5L@ge*GE$66RZdtY%0 z3By8yAcRNQUS2A$d{M#FW)+BtY_+5ygak<4!Ild!eBR|RB^O`k%J8q6kPmggDi>03 zciPx&!M)6m{*jOqOJ%WoTsc9g@Pefq^B`~lABX%iR&vgov834B;|nvb>k8@-`= zIEg=)6}cVTJpb+WQ}rM1{B)3FG3W$vArwp?K}2BZO#`kV0aACc8TmT{Z|XaGnO>2HF!z* z|8Oo~3|MAZhc0#mDxLrZq|wS@Yjm&r_gyw?Sacduz=uVr`B;m<&@Im^kO+Jj8(8S| zHybpd`^`&D&Q^>-Q>SGiA}MkV$btk&-N9z?2NZeJ1OhhuDZWX~$thksVdKw51CM6u{JqCl3i=rkW|5jZgJsAL`#L=#Ly z{=8{dl{`TpL?lIy0a=g$sXN#V{(vHHnn2*X=VQHXg+Oum_c$!_`LSMY12PiZ53bYg zepj3ee)tzSC%v3q0xFh(Fl=MthDE0(9q?h%X+GBCZ(?*;FH!=+s0;*9sK4g9V*KS~ z_y-AK;YyxPQ%&Hn(aN{QZG}Hk0(v!mw(ZW5lvcBRZmsF!b7c}vKS;pfc2ki}vOj6iGOw+A z7M;b1rdx}^f^Ui+B@wu>=9M3lnr+n&7hVECefNX%`y%k6b)m|H^#!r$RqObOG(r^^ zRdt@f1Rh?uz19*0QtJ)k7EczP&k+ANQ1{~?{6&_qWb0>D&BKK5kJbcb`b_w<_qo}p zxnPGseIPsh%hi`Y{`@(zUC9>XSWAHRm;e4-FM%iV`|DMzgrY?YTv_6$@F7H`kY?^)fuk)!fKb;!ex%HUNm*T&QDKdl${N{M%_i`%OKPd<7 zFaQ0wR%xTU#0Bss*}fV*3i|VS7k@QeQ*mYIMZNB%9XR~;`=yHI03Mw1KjVHIA_5;Qe^Pg_8S?`dscB+F zo1eG>I&v>MKd^*m7WQM*jkIqW%?fKt7|{{;s?nFsfcwwX3FmwbqR+0a_09 zXvxU|eK+CZz3HyC)r#c+aU|HEfF}3JkOShlA6D@hL!#0zv)7uJK??@mjCH% zmtawnMW?T0V(~GIa#3U^F0#1#qTUq}YH1%odi*RXMgy;d71JlrR}3vvDi%Z}6pCON z1R^9r>JB!8KcL8)CR8l1_hoH%O}(gMc`w&JSnK~)=&I13o-5bCdCKMDX|Ho@<)CF> z?O@Hzr39H!s}qe zSI&)9488KGM3k;}VyV7gqou7MtV??3mz;CHwT} zhP8;nbXe-Yd@^jg90Ki|-7FG*fHYc91ig|)rx68wSah0?wFtb>J1U4oAnZYdTRE?s zPVT1|fu^2@fQSH7ylFrdBtYs8HiJK)$eSkg&MKOsGi`;yYC>w&72i5vdAc;Ed3wd~ z%9UGQeHfG=FRHH~7-NNhJPY7d8l> z+LJ!tk|+3sh@`kN;0h8TbqAZlA5i2?6ZpIQ?VtHfiO6O*TLG)T6|eC0&_A7gamMPV)RE^Wk${-!2|;9H5+!uRx(hW`+Sw& zbJvQ_vB68G7Jm6O%w+?Y@EGSevhTy&hkq8SpKwJ5tsVlDSae#L0Us8f=3_1NPLA(T zgoGa4KmpocSdAJN6hp5p0Riz-_<)F{bOWRy0aACc8T*I=HSVnA;#$pR161{LA27izMsXN#V{(vHH znh=BKJe{&^B?iS=n6{f=7fD=}&|>kZj=?j2`$Mu0@xy{%XXFrQ9|Ky1Ku|boguob( zMW>Mld{}gvkF^La@x_$;q#%SbAOPTXrQyo=znDTGL?lIy0a=g$sXN#V{(vHHnm}M; zvGnh3g+Or(*sE3X(tW3lZ?z!6@6C&8Gr04Ks*6K*wzESo$I~zL^I-rz7M-3>0qC*l zG#_iB_rbUIH96?P>tHR<-Kdr)!p|J^AOS2$$z=#rG$&2@dod*}J^B0Wv8=fU%2!fKw;vtq((9+OV5 zF|ha)AdAApu1?4BZ+<7CC2Y3T!xKhp#y+~M7+R(_Ofzdkq%K~)9i-nkuRGx9rfYc@PqBOTN^Z<#XVK6O3f})LQbmvlhE=f zvtj&guKZcGwl1rLbNlg<5p z=OV?>`bex3v9}T_5RpjWJ`Dcy99mD-9-3nXv;aC_exS}Eh;%YTW}hc}7yRY6C8Pgp zIc1K^;>0a)j&Xs94S6JcL7IK6X3p~?Zx{Hm=sA5J zsaxmPqe$rW37FgY)Xc5o^GH)h`tMc@JyUzeAR@A*lDjtZ{CT7@7qiw{0X=}4S(D6= z+5352Guvcrs`^EntzB2R4Lv#d3KzKKpyW$(Qq4Y5X%Y11JH4%Rb4I$+8!Z4O`c6Th z(|4T#9~PbFW9?WiG5`3>B=jnl9Cuaw$5!!;mN#ixad`qgh=^>dB=qw9Zo;+4JG$8l zdg4UouitD5ZQ1;_{%7M)fsfe(vL^RX6xL%ThEN8%5L zX7EJH!x7V!ub6XNU%94cj2DPViW`GJNPyHGYzBWokvC1?Z}a8l|;QSpa&46MOKkZB|ChRKi%k!7NFB_u>cxk^HBd;c{*`=Qqg;fWOWxZ?piNMilU2(P{qHB2a&K-wP6fAC~WEvEl3%@r{-vKPUW8F#=5;8G?wU$T1)* z&y~-#n8CGej=)v>9kZ7H@FHMJ_+S2={r7R}pn$;tjYvq6Q$Ov)KZ_6uvWr$50Z}YE zjVR#5qSJh=MPSsy36gnG5KS-*`C((@qIrTqh=_$iNPyHGYzCwPMcyTD#We#oYp@ z^>JG@!SPuaoPLmiH#Onwbh8c)xQH(D0( zD}nlG$=%i}70?~1Tcnc*{?TLocjAtW1cB6ggSgLyMdvfb|22DSnKo{Ga@3%A zfzwm_1bCE4_<;*{WN%=Y9Q1PaZvJL%Yd;$uI-0cv_>bMmOcobzE8=-|5cO~EcQO-Y z#EnuUTSdb(XWQTJ6uz^EXu^fkVB$XE2YyqK{zu6xCfWW+JAa#SY|c8p3w1aDLw>W6 zzJa9w%Jv6(ed=z0psVS-`M2#E)0ymGa&#xNd@L#z&<{&;$G(#}Qnz$Gov44soy_tX z&Gx^LJjTbpWx7%IvZ`J6cuhnmSpxK(%)a}!KMnuvp#H&@r7I_A>6_Hw7BN||9Ka2b z|B0d(2r3~WjY!}=%!zjJZMi?@8!avO_Di%x4p93Y>4h*+F2I5rBoUit-)MP0E6gG3 z=#5r;cK-ITR%DwvF7OwAmFnAC4%pvl`ER|^Qcsuz?J3bev;B*lj;d7b#9GZ8N)8kf zRxOTDascRuDLDZ2A89$T>+p!-WQUU@IUpYk8oUUp?Ip<_TMkq$`1il_tuFbDX8TuI zJv)8rqiq_xdRf)3`sq;0OR`#MIdFCG^1DSEP17{}>{Y9G1!o+XbKvPp#d5&ZQ4@%W z>^8}rfl@kc%LO@b;*(XItdIkA|If6ONj1AE*WWd?(oYk$Ek>qPzZKA^QX&_)!WWxl zZ!!K)jtA^-w4gd?HD_b>N$GgNo0kK6t>hIGbkc{H1Nwf{8!b+J&#HfRa^uNaJ*MjU zR-Nr%LZJT<@x$)NJ&oxv-dtT7sx{D6XSN>tKz2Aek^_(`X)G!g(0fU8$Cd*HllP|4 ziTYQJ2jnxF?eD_N0i)_=RlDlw-z#d7B|ysohasFC(038uXz}+{Z&xe_h;vc?d_yw) zWypan@R8?lw3LWY{jER_80r7?cmXniO|wT1KPvR|wf&zD2%NY)xbLdxOZh9Xepsk<01jproVIjdw|Nbx~>Sj?ao4PlXyMW+`zfDemK^RaeH z_VZ;ASCUYKMG;sNth)8%?uwz8lXFp!0H|!KDXlW88)-AKD3Xz0sJ8;>F;y?Qp}1KU zZ1d5B`M*8gEnstl--2qC3V6n)edWOy7v-SW#{N7K^-Ny)qJ3BJGkMd6I_I88f*m&W zwJ)$AfJLXTgJJP0KsGSR>}VIwv1^{Mu17{{@*zJR51p$|LhH{NVUrKF87DrER5h`8 zRmIRUHM)U_$aIowUYFvpwDbanl0~QQwg5gXI?cyg=!M_ET#AGqD3owHZpEUPl}kNS zm!d&LWJ@Kb9wb2O4z^rSDAQLJw%IPX>Owx$`LtDwJ9Zlqw0HG|i!&}(`UTTrmrdB& zf%W7NXy0dQ(LOgo8m%XSUdf`QXXGx!6FylG-cSLs0ZDNBSO4Am?($%L?mbkzh;>Y!qYUgateY&mtw z^P~ZTn%u>7exK=w)3;a2;mi|EL6f-0rW9w!)t%0i(YgGIZj^zTs&Fm*3sKIBF6u4Um9wgXZtD zBT(_ACP*$8a#(cw9yQ>@qSJh=Mc{#@F&-oWK`_DVM76Ka9i|w8B}I4{ODu>;^um1@ z{6PYw?qDH)m$+vbr-{>@iB>Z&YHW+3iQ3YfG8H7)+u2W$fDDHtVLkKYuPhM1j679UMI@x zUZ<~O1m*u zUH5EkXrSb(@)lRuhpaVy^XHMyU5b8a3I3=x26085MJGD~vzM)1tXZJv_wD}* z+~GdM=lrXO;W#j-d~zT}&m( zNCQ4BI?cyg1isu9@&zdfVGIZW_~gvdx_N>?h=^>kCd8 zMSn$Yum(OXI?cygg|V6E^EaeagSq@wCttT3dS$NOIr6mf6?1M5oQITAF9#8kEtMRr zK?0=iU=w>sATUf5vn2&Xqiwcpvzm}xb>ie{%Nq6f58Zq(v1xF;s?p2Hk<;{r9;S~`Ec);DTx}Mj1o_Umw6EA^b z#K=C|Ihrb4Yd44Ix`Y9!p+{XeFFiaD&f=$-ixhM@gtmzff zJT-$Kq8C0o&{(-vKb^IsevN{#X)U)U;J~Z80Y1q*FeN7UEDMuSeWtGX)CkxkQAGtE= zgJKxsot&(lWJ!EP8r<;EWXwN*U3U2!VM{ELhSZKRao&?f=QG6rWu0OdVc2ukk1gNb z-4rx__~!7%SAT7egBALq>Mkm!%X?HkBL_qKPBM$;Mp;q}q#-TcfKHF~fDemK^RX6& zO;a=cNf?5Vf@d3U)Ld0xF$_&zkpvNut(Ke{g#<|5!Df(}K#@01D5VR&4YJwXsJN3X zf6R`AYF7uf*f7qe-JFci+;A>nCt2ywS}c`ApnZ16A_M}WXnhfec`Q1ODB#1Q(|oK& z;0Yi1Uq}Q#Id|{KvD@jQKKiTM{2vt~(A0T8h)9YY1G4g5A59E-vBwfY2zxXwHOUN_ z)ki1nc~mmw>7{^eGhWP@xxGg<4uRzCj92oFhH@~p3qp%v2ymm}6Iy&rLZ8apjh+w$ zIxX;k4~tIow-$!mzx_rsEG!fEbhN|vbnywniVvff=LrlUBC^%~qk^#ftEW9}1w&B~ zt}k|@&Xo?M!&Vn+-`Ta)7=Bo&`p`>-=123@m^Z|ZK*bX?Ai!A2VbSU5a)A$vPV=!A zf#q*>J|`y#;T2oAau2F0MqmjMUIqaNBy)lg5&-_CrZGRMJJ?L9qCdO+ZnGEUMFd_5 z9~D}vVBercFC*GLZxHwhryEpJul>`e%OTLNidrNCVGu{Z@eYV$(P`BZ_^{|SA8Qfl zy5o2-i9i^m!4vLFHh;HTF#>Zk7=#1>mZWAbAkeqdvwpUcf#RHuL-DYPR(FfH9vOK4 z{uI^oD;xqzRdj=PjjtVsiUr{oernW6uF# zl2fDKwpe>U&tYh0g~DH$-lkV5_Vabe>=M%$?lfJrS5XIdd|UmEKMsfE`yzoW&?$$HEg|A3zH6ZtTPO0~C-$NUc;XKGk<79W~!Eew}*{k1p= z!_}4U`A3(@)Ku&HbIIEsXX_ni-@KP27z$MgRhGpUgG#klh={jmLsbj@(B>^60pMS1 zGOJ$d4ZV!Qe8_D{_L3M&q#?BuAubTI=wu4ao^`*KF!`m{d3nID{_l35t5A3m4lFtA zKJ?lZl^hK16EhYmr69#v$|Q?UOE=)dqSJh=g<)9smhVUyf{=pgN%fY`cPfUVsT)5b zBC^$z6ElzisXN$m0fs;R`NMaXz|hipQSb*z#3pNgR2&w13_iSV@Y=m$YkxoAb4rz= zcW@vW7G5h|AyE#2_F|ifKe5 z5Qc@N8jN`~x9$}EUmar3=LrHKBEDGQuK`(*0C16-27gjIZ8ISVOWfP(Ybykb`smJM z-6sBabxrWxqg#Sj$KB1u>6h%7xjHf5VL2Guk1<&UL*ab~O=;?>OFjS4Gm}1q+F=8H zSah1dwJ_|o_xLUnhE+~4HAAoOu}Jwb3jFQ^|1*XSLmOu6bi9gT}VR_)gxZ3fG#UR{lLMoVm4~Pit zylKD{BtYs8HiJK)$eSkc_f4r^*V+nyq8NPGWlqhIX2+Tz$n5s0-sJkbaV{h~*3O5P zT4RTy;%S*%!n929OE)6QESaK*R^m6(q4}rZZ`ZKs^!N_=u;?@&YhidVdG#$4hS83l zp4BO~T{CNT`q>fROx3H0^$t-C!?GyXtYZ%l5flvV4-x?GVAB48E^nHEVZ%|=;w^!p zrKbqNADIx=X+jZ(0mafKFzbMzb${efc? zEINx1O}7??8}^it+(QV*D4I3s^z2mA>H3DRdZj9cp{d6J%^joYE+ha7NNSp^dhl&R z8WwB)I>HhdQi~C}dyJw*p@Hx9$G&X7`R(}1P3CWZhtn;A;i}Kpj*x?4{z7~f`%@1C zZov%z{obO7U*Rc$#z~(SbnkGw`Fihy?we9K-!1K2DiuEr>sf&JYuH)A+o`|VSvPxM ztN8VyXMW%ywVSI85pED%FhzPAPcU(N6D-M)xw=U`ce~+5opCr({>%Ge9YX_I?78M7T!wGvYa4(79zs2Ej0)^@loUmbeBDp3Yxs5GMbGH5cPT@Oyh$bW+ zOdMZpe(S7W=M*4t!}KaWFlg?bFukg6Qr+3(&t+knx?s7XbfR7g5s~eURjmgFzmjUr zY1@Og1}3yQFfo590BJ_E{Tl|>Db>nzyHWMBs$Dg-_05K43Ao>?K9aP5@$`>A2fEGI zf4=bRvHjMs)Sp#f-mh3D@Kav6%#0hlD<6>tyBdB5boLPvU~nV9jQNqShHn!x!Dm$F zC`)7ltb_@sC=*z8L*y#e#F5>(D^$o5#`mpM7d)xAJT9=P_>=LP@o$esRSf>4Hl}kj z0c~aOU;4XlwiXBe((WH^yx_%yu)ly=4QYG^jofKEZRdjF{!-jJViyMpJy~425Py`4 z1ApNp#Q=#)n(eRV#ertr`p;6!?V2Wvg9^g6H8&-yZMHwqZxmSVescw=yaxL9J>?I0 z5OmcaMI9tZCUPVWAa-diXn|Tt?LbNH*y14j#)*6+G;yN-72-fXquKuTcyXYitCv;n zDyLO0L&y@K#X%jRmtOzb<^3{&5t*$H!#MQd@Fi+<)Ni$v+nd#C>zs*85v?JReZo+jr{A`TQUoxp~H z_Wj9u4#R#r7JV-@(*S%}befN~bGC(!mg`8i57_3`=cZrX2QB94Lq4fdQ85Bdo$r8% zq*W(YjS3PVbqAZlA5i2?6AD>+)pv3 zx8?;73<_Dj!80G(5tw5H(#U~DN*3LP8r%T_S#+9@wFq2t{c9IF1fCjE)u;H!bM@u^ z?7T}c0--0Cn;|oYKu7@Dpbg)-fWQJ3zdT}d1P(YoZ?WHoOF=7oEQ@SApw>bTfx=<` za&>fWatO3jrwa|l38MgzM$0I;K7&Q45e0l$befN~2)wcD$s!Vga0VYl(237~ zeX1CNrcQN0LPhbcUN#SFF7bHOH4mN{7pvaphV0fjaS9@E*u)2_1b?>f!|JirO={7qj7AUp9 zTlK-14u`AGl?(8(BT%s_3IdFU92R|oWE#vMP+4@EkF^MNb@^g4i9nD~KGjq~9!KZu z3!WbrpcsMNiW}G1j1dD732jj@4E`ViQg^T!`~gMYG=acN=Bx#}}T| z|LQ=;RXCS09dmN;PA548+6RLcX`yf;iq;YVQ7k$w(|`|)PV=!AfhYR>_Lf8-9C!jH zu6rBjxk~&A{MeB0aACc8S?`dscAw6t|+Y2*$RQ;U@&p<=J6kQ-PLMy z^x-S@PPaRaQ!g0|c4+Nz+vYIj*Dp?sn^*;VuJ2mPy9;kVP=XLHyy-)&SHOigEINx1 zO}7??2cJ}$M8Xg*yiq?N(_lxDh5DVHS~STK45=#10+^V)@TRAm> zE&joXkVU6Qc%Z+s=rkW|5jeMxPjgZb!iaG0@}|NN_^JM>A^EGN*5Pz&)jb*~nAoZ6vh(OGj;fE+wvI~>1l%9zdU#QsiOwlaZ}(X)bYkv(7E3dTkq^A8kHVlx!=7? zc*xC6eRs)Dylns4Yp!j|9=%!Ll{(S*-JwsW7kApB|C2h=_^m*HL7iv>`b+vm=AOTW$uo)v7T%@LnAau3tn(Z2x8|>`Sq=I4?np&%dh{#q;!VnT5bq8B6 zz;H;o=Pg^oP#hOkE>UFY_7)K#6Sf?6oIbIAOPoItgjHLNt|W&*yCAek5CYO@E(M7oY~3btqaB8dr|3a|vEaj^)7v9~4~tIo zu@;6!n=O-^>jn7)yB3%3&%p^E!x>2fya09(5!iXt;13cYbqAZlA5i2?6Z+_e>bhu~ z!*Ex{g2zv^X%@P4e7Qv-H`}hkxsbrHPsb`{ z)xy``*T%Gd)vP#9Kj@=j;nxS*5vW)YHs@E$jPy=G6s<=Bofd4shefCPSc|~7E}zsS z5!mEKSiQ!DGR29R#hdQFQH;RyA|Q+f7epj_;XVxh@?0Oirr%}JN*QYchD9ec#G059 z5%}elaW%I6_Aq$j%xaOv>;7>92L=S5`}@^*atO@T5uus2YIr>EU$|{@NSh5FWtQ&H zIGmB59{_qZwQaJ~t`(`*e%hg7(OGqP5MopzsM39NUceWQ=lw5WDuKXw@tq5yd|a8 z()!_}s^7ie=~2gFIFLjYO`kaKn>>dhj+Om0^osI+l)8)I(s;h2owMS0BQ99ySP-&Q zNEV$IY#<0(befN~FpTgT*`9StU?}RN7o8_GoiMv=>y0&!j9lP3_y*1&=%a@lsTf(X;&V9!f*iW_^TqyoA_&bP5E1~GlbX4Jz@@>H_uCwS z{ijzAi5Sy1Y^Sd3NY%(Ur%43XTDNwg90GH7@8qV@L#nNOK8Ce-(tiE-f9o}fzQPWo zk&><3+5SJ)_06}X?H0{c>b}=NVPfl{WD9t zpfRqH+EJ3+vG-2Cc-uOWPSn3*@1%T2v;8|A9kqM(*c}?WdRf)3dOE9vnu{|?)fdGcq3VZxCZO<%h&MOegHzA^8MjNRSEcS^ zxHKt0I9dW!G#l)J^U|uT)vSyN;@HCf0rGaa^)WlXyh_a58ioG zWG*F(Hl^-jxHL!13sw0mtX-m?1N_JB?7BcC+u7=N8~Rik^n1$*kIys?ts6gf;@i}A zxSg#L{9fS}5k?_tfNoStMDuif;T7iRGzM;WT-0zh8-{AXUt)$fXIh!v71&Ihvv2h;a2l z5y?bcSOY`{2Ni0Q?*x{ZivM@wes_gjNDB^kleq6{g8sXy>Z`nPSj3|(Hqj4w@HSLD z$gMJO5!#4g;S9d`n$Q2J3~qCdD9zY(L;rCWE>-=>35V~9zVT1W8>P!i-iW=JX3YQn zsZK69zRfib)x{>}*AqvAe%QdpzZrcvAbK%OL_de1__(C_7;VzV6$!2w)O06~vLQ>I zCNRcK#GkxZ9Ip;Z5;bDp41LS{`e&)Q-rJ*8^--m8(kcy92 zdC#Q<2oZG?}Sehxf=i37;}L^`f${DZz&5<`9D z&}HqMQ`iHk8XvFl$v#Xobh;>M({FhOzq&DQJtmW$6Vr$nu3GgRzj#XJV$GJt&TTMa zeAH&_877(DzDzqdg4=A4sr)Y?P34@c)4bzD0wZ2`_G1lkjZSUy1qFA<5PcY=P+}U6 z_ejWwC!5lEdUhVXJ9=@)FI7vs?b7#`jLuXlpgU6Ipo}Ufv{!rW(zEC+J~SP-oP-%k zD?08-(Y#iD(KWr}K+T;kPaU>D8?1?`a(-8d>BBUe?(W!DxLleBcO6eJO_XdzUvhdx z;n1&k>4Sv>x;M9stD$&QQ3*vLRGHDD=OR8L4f2A1HaMW`|8{sKjOK293b;=>>G2ry6pf*$o`o{ z7@;u8abblQ>1li@(au?M>6gS`SciSUk)#i)TC~veck3%xnmg<=+W1rBx7+j5PVZ#W z=?y->hefBSf2~E}vaUlUlywF4F+;;R7u8ma;k04`F~;7>}YZ6>xIEG+e~x~*VX zT}Y?;S!J!hXyT9-TN<7zb*RVQSWE|1bnx7%8FC1;3qp$oAq!FQWuKRN(%)DR0-Y9k zz=uVrk!dXgf4Ww^Ac?>xsUDw=D{K&i`!+7GnD9{?Te5}@m=xcj7N$!C;lzFCTfCqmROHj@~y1uwv0^ z{Sx@F=rkW|VVHGc;dT;+Fj|8HQD4`25Uv=8IT;p00-!NSO=*=$-AJ1W7^XZfvcXm` z6!lT(=ks^(KIap*+hgIu?NxOXaoRy2t$A|lAv*#U3&IQh)Tq$}3?PcuBY{o}HsHge z(|oK&;Ea9)B)8cg-(30GuX7Fh=rf;3$}g*`AcDadF%XgHh5Io0%X57+uxjOzHb>x` zMQu8(I&W*S`1SW+w&}Ij0~Z1y@bg8@cgZ2pJ|eVeLizGs_4Kc!F%OkXjerof*}Yt`ltq|qAWVCS^^&yo#taL4AW#^( zGhM4Dhc9}qn(8s(}n!_|63cUi<6Z*EUy0FJG#6E%5hRfxD7EJZ?Tay()>ol#%P^ z${{enum`R`bz$QcT=(er7VWu&i~1TTeO}PL!|CShy$iZ;O5J?7v~#IcyeHGM0PnX{ zf!|$c$G;xV+$UqdM*G_F9-0j`9VWEtsM9>GR{X($*8Mbi`+zr|H9|kKxGR+0+M`{O zvn8|MtDL@eaLH~_aZov2-0yj>s*-qP3=W6)+6mPqIAMd;s*SfBaZTW{$I#_>!Za$u zJlp<$r|_LUG+_Rj(VsiV0w#_xm0y|Bca~fKg5~{93C1F?Ef0 z8-f0Wx<(u5Pw8v4e_ptK8Y$^<362-CPL?1`y=f=-b;2bGsglNGpm&nwj^9DqtMtI2 zxp%_!sf@#j4hWf?r9s;;NPYEU#9KN@#0fLYo5<^M?YE zW;ENscZ;~pGvjv}RWGaBRipkoyqYWl`Y6bUk4C-j_xVbFd*K@G_dCvvR4fjPip64F zA`kh9G@=*o!_e^a{2J}wJMKTOKpcphwkU;6q>~vkdyV!HkHz`gRT$VN9TT)`LIa;Q6`wC9#lf7+|5cC^2lkVJ z__QECiTIyA8R%58XCvK%o%WM~2oLs?fzYD}!%?srOkt>RAfPWegU1tHG@NNTXe2%0 z#(T>7Uqb80X|kUT#8qafHdH+5(1`tHASx95$-sZ($-oc&9?dm-GO)|h(FL17YZx-! zZRY)z1!`pCZUu(8ufM$^`*5I-01`ao3B6g4PVj8w&%|lyosK}K*R>La4b3b%iw{jF zr~EYcHCK*ai`6)D<}i)(mW0SIQDX%AWDTC@Y29tnZBidkL}x53;u1qYwZpR--T@z{ zwb}1pYM-l1$4eZw>DGg8a%y3&7a?oUHY{+^duM=7FJu587MZ%oY_T_CKMrW=ZkRI@^@b|i*Q4We6HoTpJ~27Jh@!|8PAS! zMVR2OO^_?XT-`+zSgBZ4ySDSV2R^u1C4a=rZvBAFcOv2?x&A<>%rxFkC@VaHri=C} z+zX&@IDR;eoF6beFHBtIr|vZddOzx3W9YV6bQT|)jvIzGM|}0p-;W|2#zNubt($PK zae=RHtW!KafcrVB%CZoN`z@9p@%5MbQ>pU&UgPYgkDFs{&B`Ob;xqtt#8;$42C-@O zUgPf90?WjEKMY+n_s{BAPnQ^t14(w#wEbycfE*0l2||>Xr}+i?TeM^aD~PNoYmW=- z98SV&B#vD889@i=V*P>7kKhBF+%i@djkE9c_L(=enqD4D(yw0Xqghseqf^0OVl|c1 zy3DBbTYpWfA(795ZVceo;6@7J$pl|Hdm%jR!7nAV?(%DJe=dAb1Fyj~7yLTGk~%HS zfle=}3*p2B;*8(h@JlAy^079Oqr}jW!Ui~+PL~o+jCNuA$GMUiR-{0uw*k>rg%fkQ z`LLq7nix9LJMjY=kLk5bL(}Q@f)kTeqQZw8i?Kjdc(KN%06mrd9V@Tk(W5=#%#E-v;!mCt8zx^>xu5-zC zO%tRZt=^;yN<52BLkIY<=rkXRnk1~T-xSm%4QKD8;qCo7O|y^F z!*(WK(N!vwHJmHLz`&vNdJXBXM{4 zhKm7JG-R939`9~gVHNyShFN!iDu7@WWk4F=V})tn32RMsIv{fxyp^kpa*V1tDkOuf z3fA6*>4IM;EM8f~0OKP%yDq||5_IuEpG?yQ5za+PEBAa=@JfBAb05hQ;u64zOej~X zalRvg^J}%w7w4PYhvTMxv*&NQBKidPC+J7F*28#<1^SUi#L_0F3Vylm9egnOE4Cyc z2&Qq%6w<-DKTjKU$$3S4O}F-MZXX*vl+zXz!3PFo^!Rk%_JYHA&iaJgx=gN2@u|zs zlDboA$5+B|Kcmdi^fZ0F>J`4(6Q*e)+-lJAqt)@LeP-+V@F?cSyITh*?$qq0_PjI` z{5x0lNiY8E9MM07i>KfN1%?Z;R?R5M(|I|XYk>sP1^84*I4!Me3Jsp713>8Rn^iEl z`-V*UX8bySyk9>}%+N&x9A_kHHVs&R-fiL_v31}~?`inEGudZcfA*;ZX_o+`tYZZ@rOcPK>P3!0~scNX_ zvUb!v0v5xmQLjjcsIkeq*h;)jAo#c7>JICsH(%dWo8Ythz-b()&<7{OEV9p~@kQn2 zRIW}w;aJ%}b7ig6T@07T$1U19D{c=Z@mG%e>(joMgP&L3V|0k})z7yaYCql0q|=HE z@L|zud0;IJ9Xui=mwFs>tx@j#(YwUkt@aJRJxMVP%W?&Z|454%Qy?PzZTK1d<@q5> zb@#HPEP)}w&QjBm8I_8)H${ZupOMd8M(o|B*;MuI{`%`9v^cP2@~OnJp|Tpa9fquN zLb^}^P8bRRH(K4P68+#{&#c`>w_5?7h86H((P{qH!tlkM$SR~Xd~~GF**BebY2f@u z(5=8Y#V|B=yA?zv6q;ZdULt=}^Su^V?9%XoP`hu5nG=g($bwan!?PiCrW#8_pwm(h_^{|SJgtS{qpN#- zNEnvXx=(lg)F2IuJlgnWp1=?ylETLTuRNEAPDc`U+8l-hP7H73q^a3*L(QHIJer&s ziAzHw4Zp1DFvAW*#V`aZ#)1!vPS1`39~PbFV=W9T=Koo;`T;@;ZkU=7S6i zB+zN;27Fj_nvbx?&hs5K&<)y&xjd3-@90m*+}p zmqWW+*&K#Nzt~>VFSvi`YNxp=@ly}o!i69i8~!gW^g^D)(9D7b?A`hoZqvK=e3(`j zzDHA#+NKBeSZbTzt}jwo)gQh`!=khJ&~$5I_+nYaBNB!yiq~m5Z|ok8hp9spK ztVoNHX1hA>NUh)dEA9ev$=I-9^3!*D4ns1@#@~jn(bx@Bl)8)I(s;h2owMS0lk)`& zkYX%ll0~Pb8}MP#X+GA%a8Z%SJ0uK2NWnzq(HaFSD~6$|JLe!Gz6#*4p(-E&;372* z{-ku;Wa6Bt57WUD26R!D%< z9c;M(!+Yt?mf0MJProdXS!&>mu&>wpX8Acjn2GZzQA#UUX!5-shB<~IEv*2CEIKXq z0ER3&&Bt08&ae3@Ne+e}j2!yEq{G`DQ=4Lkg?Q{RB+vi&Fi>CV4lD(?g z{;j_adh@<}x;}uqeXb_I*Fk@Wx_z#OK)*}fJ_q#Q=-cPwdmNoYb~bo})OZ2dZ!K67 zZYTKVwkJcXq_L<}KyM|<9s9bWxi=>7p%e8|CQ<+IZl9CSXtuw%S8SCbYj+z}FRR*B zC#DCSBTIn3ZfNbb5y$q=TB~m@+&(wzi`#!HmItelx{?n%(uw+4$OQR}X8Z4o>HOPy?>!p2dRf)3Dq6i@ zRk8$VnXs`{`)yh}Kv& zOrX0VdJyM73H^;hu1TEhFvK78bLPw>mAlGA4Dlbnhwe^+9xID|w8wrA9cp6sd+0F! z@DG5;+lap$LJ2$mwBJL=6$mafd|hw5@-1@Y@CM1T!EJ+&EqI3Rj4 z^o@TGLGf`(@iE$@jVlsd9T9=<#8Eb6srGy5{*Cw0=>{)LVckO~4t8&xYCUP;?C8+Z zySsU3Kigatw-d==_r&_jHRTkWTs^;Z$Ybe1-POj-2~fUa{~J&9YUVsEzVOmseXL}h zrcwdDAT=VY`2In=NXLD87M;b1rdzuX;d68RU*veBP{!idCrj;<`ctPs7)~9+!Bip z?67I}H1E^+-mYt}l-F!NdF1Afo#8*=K!p~lK8SZhUOIZQP@cmO$IAYhTk}!sE{03v z;}-3l6<0w?{FS5Ayt?{tj-Ot?*J!Kg#2;1T3lC<~=`EqahefBC39W^pXXWBqBn&_Q zG;qlZr#<3n-XEKs{y{MeO>K^Wh`2Hr{}`$w&$o&WJo~7wB`{6C!Ro@x68Tdr8cRc<(^3!ku;?^At%c#im-7~oFkIcaU3sVU-J&%7pqaEUPhbcU zNvl?@8daW4!()ZF*0i}aJY6}nRr`sfLU+1+C|_w;(K@&^B+^hHzjB3L8s=CUvf#s_ z)2DVp8nWm#A8TRw$K`<<5{4k8;4p3XS2Y_ch9O+AOG-I_9Yh3n-Za1v5+HR4o53GY z#?Gc=%f2+ievNx0)E0nN&1AI1=YV0>fKXyFIYOP%#W)Oh@mu23WD^ zw2}#YSah0?wJ@wZ^NHl`P#ChoVcOQ8yC|Qc$;sFd62O9&Je{VRfT8a2jNLYe;jh|X z`jo44rbX7vf?tPJ+!cb;FHuV0>+8(0!%#5{{rQmAbL2 zb?A~$Ca(P9yHbO3DM(-#RC#RPOG7gY7XRYYy#4Plx*vRLujV7_G%wKOsnfhI+s>|A z+;N|VMQ8D$>DI!q{q^}NBn-U^G(R(-)IN=uaGLk-!cX7i2!_H!gwcY9uMiQyPwMX< zcy!}=NX!*WU`Q=Yh#Q|+bUs7;U$duqGw(ki>l^>P*`5be+t(|yG!qAtD5Z-hy=i2Z zhB=moEM<~Kr==T6Ll&LpV=W9HeS zIExk&O6in+uWwiaL)O9si!R2EKFlsyv>MgFhhP5a@LB3AJAUbK`5q1|f#Ii1*7dZ* zP%#Wa$)r!)!q|{Sr^kB0hefCPSPR1@tM{HIr6G(B;V|uxnwx9n2@D}3velAPIgkLU zJJ@mohF7X@IAL=bp18B3>#+Zo4qDQ*@DxpSn_qGMBuZ)4thux7Fw8LwX=w#8WYKA< z2QXyOX+GA%a8r>5N9AA$!f4jjRnazqAtV5RCpB{chO3Tt=xB2oE~$7Bi6C$~-=IdE~vh7I}_!fD>A zPd6=7EE8aBH>q+#-@ccRNCS4>H0-?0^V7Urns)bAAQQx$mDC7Hq>~vkdzyFb#uX7i z&HA#{#`&9Wyq;fd4-PC*&5rNr`OpwoLwtvgsDX}}h-K(LimsRa5-HLDWktIOOgkOB7edTdK_sn)iRxYuWypf)2Z8FYdY_p;emO*&Zc&x*x^m zAdw0Ax&(KYlL_|Iy!eE#8#>?HTji{ZL??ss3F07CUv!o@Le&q^6VPekM08Sk7_=>> zX=rrvUX;3v;nHZn{7MZ_k-z18?^V&>z4P_$q~AkF_VB;tars8-z`uspc|3iu{WLEs zC;Mq$Xe`pE15{)dAim+#ewvpn30!9Qs45hZOc~lw^YTSxKh10TVPt%YyFHROeN-vj z-4lt(E=R*7PdI9Un;!n3uSg-seEACe8&C62`u6dAv!{8N`HXiBdo(y;LBNoS%a#}L zMOmg4oBG|NXvO9O`eBdwht35%f&NI+(e^+mT^R2tEluUj9i2zkuIkUrHfT{rlhvc~ z*yPHUDvd&J@LHXScYMD7+X-c+RbH_8UW4rk4MwU|&P4@gT<3tk{RYOyG%fbAqhF#f zE>f4Mj);#-*2N{OW3_SGKFA&!ACVG^2-uIKpWw<_9Q|~0snLn?ah$VkB@O_8l{a% zLN#Q|?dK@O6oZAud(aUSeXRlTcx(lTs2eYlz&@FFG~>)s$RByoUlJs(G3$J4e!oIyx>@CtpZh@$!5GUr-XLxeQRJ#A%a~qWi?548>|u{L!cmC1uT{ zj_FszEY;II6Vi_)aNp?2NL?I*fzY(LWY8WZToQFrI#e?eItv)d_~m)|HIP(>AA(%6 zS{D_CIz20_sLYVhk!&u}hKXBXry-6!3+fystJc zP8S1B!qE>w1b`s)R!u#+A}aXSRLr*fx32YPj{~nw;)ds4>!LCn7fbyM?d3^v8gr%^#a=D z=m-Q1)NMjy8_1{DPZ!%8H7X2e+|i-})g`Ip<7C>FyhmW4lB82dMkn`0O*5{KB(%^b zBpx6X9Ri9gDkgpqN>s8gI<7bBef%1T9wDUAdm%Zej*3r2D36L!YvVB7qY{PaF~(h* zS|%?|v9lyf`64sL6@>uCxM;XGmyj4Af%;T+A8l-`R#J#OyyZOt8!{9sKy9*1Q}_Dr zuH4Vl$J^J#$K9_1=Lte!ele(9)F!G2#3%Mcfd(*QrF`)Wkd)_i84(hGNhxBcbaC3= zF*>z21~Jt|%CMDsfFuc2ss##dNOT0>NO?-p#&Bv(VmxX9%*ftBpk6xkxt-Li>P_k=j8q(S72=(v<*9S9MWAeW}zt_WyUG=ewaG6=O5Ajyczf4x=;hha+Y9~ka1+A|o`FGp?<8F!lILoisKH38P+U;K7epE{NxD5$K@}3Ifr{xA~Rmi-(8d_G(fSSj8VF88 z8Xf%xvAqgTqE{pr`U#aw79A!-mK(?<*AKxC2?uKmf}I0j%X5IdD#?LSYEj#xTAW{> z#P}4Xe{iEt$hw)T6|{9U8;}$&_Cb;%k<i~oU5e|GnNIougOnij2QA6*+C53Z_5Q(}3oi^Dx1dn3E zl@EaQFS?narbNzxh^2*e!GWl)N+xC^;$wRwbuE$~sTlHa?AH(KgyH~Xt{%8CeG`|& zh*))RZBldu8Wr(FOBZKhu)vR+)zOhnTp9{LH8!a~;O63tXM>P-!-a73_G;)J?B$E5 zj@(1lo~~|aI1}m>qV@>%_3`mUlU9Llfi8SPa0Gz?UT#51(yQ@@n*0J6S63J3=(wb0 zEgm=GAnsnCL7whD0cua*AoM3N$Xo5}=H;ahaCZ$34e|7L4fXUTg5WWB6PF-vn#9F9 zE*_~rOP^bC|L_F0Y zP@Vaxk+Og%PxwqXap5&6G=&DU&v|o#aGqToOtongAGN#KIB=c(}(2 zZ=`h_F|aHR(WnH4-Uw3fR^Q9plGw@Q<0&x%C$VC@y<8jmx_Y{~qv~<>auOhUDhq>+SC9;ftD)OnNOT87=Cc z&>S`tEJT1A;(p$IyNrs_q7g@*cr+~Sov2L|E0>Zf#?V6Q7&qSJ#z=?*BtarhEr=h@ zX`;CtH9yjflyVW&LbGU1h(~iYebw4nq!EZ^AvQ8giXj3)6E*Feu+YXN^wp}#rYg;h zAk)kjN$==nG+U+?WGyg(33xQ=FR~DNIcWf-AVU}{>w@CL7hq0`gkqS3`a#>HtSS-0 zdk)HjWAP@BJpTHhDfAJha@bob3{pfh#@7Kh7gViGB^D!aTWtfl?&rgQg<Vv+#mgGtMN%N8+2slJCsS^5VT2m=I!HCewr~ zE6Y+ZvW!h;mlNU=Vb91e8If#ejX6=7m2?Jz%4nQvIbV#-GrWq0AnPv4o^gGd4`Z6W zY|-FpETRJk(JnMVk)e!`G%g<*PmJP`_h~9NlPv{hLXM-PJWVoZ6^$HMNz)-~SOR8VqCNIW^? zO!*KqD-l&xrm>n%4ynaJQb}bTO6o2K18qZ;FhbReRblWThB06pwswf^!D>Cpuzdq> z(CRw~O}(O(>p^%DmRczngsO};Az?_vq(FjJTZLI%&Wph+nF%Jh6iOT@VHJT+R zuxz`D;t+A7nE2u*ijm!DqS%s6AVw3#9ni{fbi7R_ihFA#`Uxuqd@~c;wxP|r`*?b} zxw^W0HT3ayZHVUUyvqg92k_~i$fz=7>K#12DDjxMd-C9S4>vS>Q+N1F*+JlrBpVZB_zH7IR{K8z#AZBKN+n~_%$GM%f)V0!6zl)ont5=5Ji>?!@IqF0;^AMfOwo zjYJzW_~hH9mkM?F4RR0m^;WxjdV8bQuV7ELZ^Mufb%2*=pm&g0NJDpDa&3xV0dw_o z3w3u>y9WlKt$}VK9_m0J6vV^T+bhT;DA32l&E2S%%BB9vIihbg+SQO06Q3*;A{3rj zk8;44nf^tM1PUJSKE|85@rs~FF!UmlL9xgbqA{LNmSc#PXwkkeVHc;AF=LkAG+)@w zff9-njQ2uHxw59qO|vByfOXVjf-;803U%%<6pBzC!Ea)POmov}astD2eg`Dtl>)R+ zKZkq_z~{F9OSqx+dn+3ap|C)c$qlxAD7uj!uY)))}vATa6bo?`pIh3;E}#0nomK9CFkSq&ZsO(?FeTWs)bm0l+l+M0T;U z+FVOqk{0cI;^r@Mjb+~yw2!K9bd-o2>*^#rE+HiuNoAH|uj`)@orrXPiz+xiB{>(l z;gbh=mkbmYsN@W-wS7FdQGlVhayo7FV6N=Dq0=gzI&^E#ZB=(hFT~`*M#rg$1|?9=i$v*@@D;Y($!MOEF!JnWbUz7mK~p1BBojoQw?qLn$5rB4o}Wbj zGsjQjS)L!I{s|mG`y;bV`IKiT>VGB}iGJi+7&<5N)F+oBBzMRZQ9k9_v2;H&ffQd> z5cvrBN)y-_DS>2qd7tuJu=ZyO5A08#17F!jJpQkjE68mign{S0rf*ucQkrWkRq0pz znPv>O$MyoDm*$YeGM;$ZC5$kGO1_v!M~+!c>+SFucFd$R>fG@dQ%c|^pNl-raQeSu zGrEbwC2Lb-n~V*+WXmFNlQst}`8oS2x6L1rQG;G3e97AGOXOZ5Eu%yG)zLeg$Gvcl z6IIURzT~_@@)f#P6&c*QK%a0y?-jCfZqYZ_jqX0(X^&9tZ4nZ_%+Lj2Ass&zN0YNk zKIJiaMa5Tvq&Nw^DaQ#(64Q4j_W$LbCBoD=KuRa$RbU(OW78R)h&BXdwqDpc6{xll z+l85C5OrB^FklpAe(k*Yd=aC16V!Vh-W2mhP5)&T*nZVggTHBE;5bc1%}${i)9iu5 zoa}TGs|9&&`YF#$28J3xh;_}OU=uigozS9lN&J3>lSHhP@x3eUEP19+f7w z0%2?`Nv1d}57};}fEb3M@+ZdC+t=B=iljqy1d_??r}1rNu^vnFA7YNdEq42`c1pUt z0wFmz@4!xlQ%l6}0TK6_Jifn?2g4bS2e= p-It_}q-H^qLHX=38<_Lj!8dZWPCRhu7pL^dsYdeodFe;;JOGXZzoh^G diff --git a/assets/logo/logotests.3dmbak b/assets/logo/logotests.3dmbak new file mode 100644 index 0000000000000000000000000000000000000000..94756b83268a7cad0818dee20d0caf4b4853b78e GIT binary patch literal 680797 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

8t1hK9r=mY`OwAzH47W7}( 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 O;SZV|-j{ELyZCPem*Q~% diff --git a/deps/eigen b/deps/eigen index 5226566a..fcaf03ef 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 5226566a14ddb4d84214c40809531038f087d187 +Subproject commit fcaf03ef7c9accd30133de9e9b4ffa22e35cf241 diff --git a/src/gh/diffCheck/diffCheck.egg-info/requires.txt b/src/gh/diffCheck/diffCheck.egg-info/requires.txt new file mode 100644 index 00000000..24ce15ab --- /dev/null +++ b/src/gh/diffCheck/diffCheck.egg-info/requires.txt @@ -0,0 +1 @@ +numpy diff --git a/src/gh/diffCheck/dist/diffCheck-0.0.9-py3-none-any.whl b/src/gh/diffCheck/dist/diffCheck-0.0.9-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..2c20bda8d8b16fc33915b2607643451a74f41159 GIT binary patch literal 10222 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 literal 0 HcmV?d00001 diff --git a/src/gh/diffCheck/dist/diffCheck-0.0.9.tar.gz b/src/gh/diffCheck/dist/diffCheck-0.0.9.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3723559434c78b74e9e877c6d7d7871e5aca4e0b GIT binary patch literal 8196 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 Date: Fri, 19 Apr 2024 15:18:29 +0200 Subject: [PATCH 061/141] WIP-ADD: DFTransformation datatype created and code adapted to use this datatype --- src/diffCheck.hh | 3 +- .../registration/globalregistration.cc | 29 +++++++++++++------ .../registration/globalregistration.hh | 23 ++++++++++----- .../transformation/DFTransformation.cc | 7 +++++ .../transformation/DFTransformation.hh | 25 ++++++++++++++++ src/diffCheckApp.cc | 24 ++++----------- 6 files changed, 74 insertions(+), 37 deletions(-) create mode 100644 src/diffCheck/transformation/DFTransformation.cc create mode 100644 src/diffCheck/transformation/DFTransformation.hh diff --git a/src/diffCheck.hh b/src/diffCheck.hh index ad474536..84fad487 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -8,4 +8,5 @@ #include "diffCheck/geometry/DFMesh.hh" #include "diffCheck/IOManager.hh" #include "diffCheck/visualizer.hh" -#include "diffCheck/registration/globalRegistration.hh" \ No newline at end of file +#include "diffCheck/transformation/DFTransformation.hh" +#include "diffCheck/registration/globalRegistration.hh" diff --git a/src/diffCheck/registration/globalregistration.cc b/src/diffCheck/registration/globalregistration.cc index faa9e13f..139ff220 100644 --- a/src/diffCheck/registration/globalregistration.cc +++ b/src/diffCheck/registration/globalregistration.cc @@ -31,7 +31,7 @@ namespace diffCheck::registration return errors; }; - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, + diffCheck::transformation::DFTransformation GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target, bool voxelise, double voxelSize, @@ -59,16 +59,18 @@ namespace diffCheck::registration option->iteration_number_ = iterationNumber; option->maximum_tuple_count_ = maxTupleCount; - auto result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(*sourceO3D, + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(*sourceO3D, *targetO3D, *sourceFPFHFeatures, *targetFPFHFeatures, *option); + diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); + transformation.transformationMatrix = result.transformation_; - return result; + return transformation; } - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, + diffCheck::transformation::DFTransformation GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target, bool voxelise, double voxelSize, @@ -105,10 +107,13 @@ namespace diffCheck::registration *targetO3D, correspondanceset, *option); - return result; + diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); + transformation.transformationMatrix = result.transformation_; + + return transformation; } - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr source, + diffCheck::transformation::DFTransformation GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target, bool voxelise, double voxelSize, @@ -149,10 +154,13 @@ namespace diffCheck::registration ransacN, correspondanceChecker, open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); - return result; + diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); + transformation.transformationMatrix = result.transformation_; + + return transformation; } - open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr source, + diffCheck::transformation::DFTransformation GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target, bool voxelise, double voxelSize, @@ -193,6 +201,9 @@ namespace diffCheck::registration correspondanceChecker, open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); - return result; + diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); + transformation.transformationMatrix = result.transformation_; + + return transformation; } } \ No newline at end of file diff --git a/src/diffCheck/registration/globalregistration.hh b/src/diffCheck/registration/globalregistration.hh index 11fe8877..98b04da3 100644 --- a/src/diffCheck/registration/globalregistration.hh +++ b/src/diffCheck/registration/globalregistration.hh @@ -14,11 +14,12 @@ class GlobalRegistration /** * @brief Compute the "point to point" distance between two point clouds. * - * For every point in the source point cloud it looks in the KDTree of the target point cloud and finds the closest point. + * For every point in the source point cloud, it looks in the KDTree of the target point cloud and finds the closest point. * It returns a vector of distances, one for each point in the source point cloud. * * @param source The source diffCheck point cloud * @param target The target diffCheck point cloud + * @return std::vector A vector of distances, one for each point in the source point cloud. * * @see https://github.com/isl-org/Open3D/blob/main/cpp/open3d/geometry/PointCloud.cpp */ @@ -29,7 +30,8 @@ class GlobalRegistration * * @param source The source diffCheck point cloud * @param target The target diffCheck point cloud - * @param transform The vector of transformation matrix to apply to the source point cloud. + * @param transform The vector of transformation matrix we want to evaluate. they are applied to the source point cloud. + * @return std::vector A vector of mean distances, one for each transform. */ static std::vector EvaluateRegistrations(std::shared_ptr source, @@ -40,7 +42,7 @@ class GlobalRegistration * @brief Fast Global Registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds * * Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). - * point features historigrams generalize this concept by computing point features in a local neighborhood of a point, stored as higher-dimentional historigrams. + * point features historigrams generalize this concept by computing point features in a local neighborhood of a point, and are stored as higher-dimentional historigrams. Those historigrams are then used to compute a transformation between the source and target point clouds. * * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). * @@ -52,12 +54,14 @@ class GlobalRegistration * @param maxCorrespondenceDistance the maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones. * @param iterationNumber 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 * @param maxTupleCount 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 + * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. * + * @see https://www.open3d.org/docs/latest/cpp_api/classopen3d_1_1pipelines_1_1registration_1_1_registration_result.html#a6722256f1f3ddccb2c4ec8d724693974 for more information on the RegistrationResult object * @see https://link.springer.com/content/pdf/10.1007/978-3-319-46475-6_47.pdf for the original article on Fast Global Registration * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation for more information on PFH (from PCL, not Open3D) * @see https://mediatum.ub.tum.de/doc/800632/941254.pdf for in-depth documentation on the theory */ - static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, + static diffCheck::transformation::DFTransformation O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, std::shared_ptr target, bool voxelize = true, double voxelSize = 0.01, @@ -82,10 +86,11 @@ class GlobalRegistration * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures * @param iterationNumber the number of iterations to run the Fast Global Registration algorithm. * @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace + * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. * * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html (from PCL, not Open3D) */ - static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, + static diffCheck::transformation::DFTransformation O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, std::shared_ptr target, bool voxelize = true, double voxelSize = 0.01, @@ -110,8 +115,9 @@ class GlobalRegistration * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. * @param correspondenceSetSize the number of correspondences to consider in the Ransac algorithm + * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. */ - static open3d::pipelines::registration::RegistrationResult O3DRansacOnCorrespondence(std::shared_ptr source, + static diffCheck::transformation::DFTransformation O3DRansacOnCorrespondence(std::shared_ptr source, std::shared_ptr target, bool voxelize = true, double voxelSize = 0.01, @@ -136,10 +142,11 @@ class GlobalRegistration * @param transformationEstimation the transformation estimation method to use. By default, it uses a point to point transformation estimation. * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute. * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. + * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. * * @see https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC (from PCL, not Open3D) */ - static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr source, + static diffCheck::transformation::DFTransformation O3DRansacOnFeatureMatching(std::shared_ptr source, std::shared_ptr target, bool voxelize = true, double voxelSize = 0.01, @@ -151,6 +158,6 @@ class GlobalRegistration double correspondenceCheckerDistance = 0.05, int ransacMaxIteration = 1000, double ransacConfidenceThreshold = 0.999); - }; + } \ No newline at end of file diff --git a/src/diffCheck/transformation/DFTransformation.cc b/src/diffCheck/transformation/DFTransformation.cc new file mode 100644 index 00000000..9bd4d62d --- /dev/null +++ b/src/diffCheck/transformation/DFTransformation.cc @@ -0,0 +1,7 @@ +#include "DFTransformation.hh" + +namespace diffCheck::transformation +{ + + +} \ No newline at end of file diff --git a/src/diffCheck/transformation/DFTransformation.hh b/src/diffCheck/transformation/DFTransformation.hh new file mode 100644 index 00000000..e6e13ce1 --- /dev/null +++ b/src/diffCheck/transformation/DFTransformation.hh @@ -0,0 +1,25 @@ +#pragma once +#include + +namespace diffCheck::transformation +{ + class DFTransformation + { + public: + /** + * @brief 4x4 Transformation matrix for point clouds + */ + Eigen::Matrix4d transformationMatrix; + + /** + * @brief 3x3 Rotation matrix for point clouds + */ + Eigen::Matrix3d rotationMatrix; + + /** + * @brief 3x1 Translation vector for point clouds + */ + Eigen::Vector3d translationVector; + + }; +} \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index f4161c76..8c936af7 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -65,26 +65,26 @@ int iterations = 50; std::vector> registrationResults; // Testing the Fast Global Registration on Feature Matching method std::shared_ptr dfPointCloudPtrAfterReg_1 = std::make_shared(); - auto result_1 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation = result_1.transformation_; + diffCheck::transformation::DFTransformation result_1 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); + Eigen::Matrix transformation = result_1.transformationMatrix; registrationResults.push_back(transformation); // Testing the Fast Global Registration on Correspondance method std::shared_ptr dfPointCloudPtrAfterReg_2 = std::make_shared(); auto result_2 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation_2 = result_2.transformation_; + Eigen::Matrix transformation_2 = result_2.transformationMatrix; registrationResults.push_back(transformation_2); // Testing the Ransac registration based on correspondance method std::shared_ptr dfPointCloudPtrAfterReg_3 = std::make_shared(); auto result_3 = diffCheck::registration::GlobalRegistration::O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation_3 = result_3.transformation_; + Eigen::Matrix transformation_3 = result_3.transformationMatrix; registrationResults.push_back(transformation_3); // Testing the Ransac registration based on Feature Matching method std::shared_ptr dfPointCloudPtrAfterReg_4 = std::make_shared(); auto result_4 = diffCheck::registration::GlobalRegistration::O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation_4 = result_4.transformation_; + Eigen::Matrix transformation_4 = result_4.transformationMatrix; registrationResults.push_back(transformation_4); std::cout<<"Iteration: "< errors = diffCheck::registration::GlobalRegistration::EvaluateRegistrations(dfPointCloudPtrAfterTrans, dfPointCloudPtr, registrationResults); std::cout<<"Errors: FGRCorrespondence "< Date: Fri, 19 Apr 2024 15:41:00 +0200 Subject: [PATCH 062/141] FIX: typo in DFTransformation.cc --- src/diffCheck/transformation/DFTransformation.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/src/diffCheck/transformation/DFTransformation.cc b/src/diffCheck/transformation/DFTransformation.cc index 9bd4d62d..1da89be2 100644 --- a/src/diffCheck/transformation/DFTransformation.cc +++ b/src/diffCheck/transformation/DFTransformation.cc @@ -3,5 +3,4 @@ namespace diffCheck::transformation { - } \ No newline at end of file From e64d6683b8817572dbd3758593ea69d0d1e582f9 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 19 Apr 2024 16:53:27 +0200 Subject: [PATCH 063/141] ADD-FIX: missing isntructions for package --- CONTRIBUTING.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6121378f..ce35943e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -77,6 +77,11 @@ C:\Users\\.rhinocode\py39-rh8\site-envs\default-wMh5LZL3 ``` > note that if you drop an official released diffCheck component from yak, this one will have the `#r : diffCheck==` notation at the top of the script. Get rid of all these release components before to start and be sur to erase again the previous folders (they recreated each time `#r : diffCheck` is called). +Build the package from the py source code's directory: +```py +python setup.py sdist bdist_wheel +``` + Lastly, install the pip pacakge from the repository in editable mode. This way, all the modifications made to the source code of the repository will be reflected in the installed package. Open a terminal and run the following command (replace the path with where you download the repository): ```terminal C:\Users\\.rhinocode\py39-rh8\python.exe -m pip install -e "\src\gh\diffCheck" From dd8c8e66b7b7e0892fef31136bf1c145fa2a4fc4 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 21 Apr 2024 10:51:48 +0200 Subject: [PATCH 064/141] ADD: tester gh file --- deps/eigen | 2 +- src/gh/tester.ghx | 813 +++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 766 insertions(+), 49 deletions(-) diff --git a/deps/eigen b/deps/eigen index b5feca5d..2265242a 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit b5feca5d03185d99fe011bcade16a181f567fca0 +Subproject commit 2265242aa121742dd7e80a0167228b43e95bec62 diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx index 6ccbdaa3..904d106d 100644 --- a/src/gh/tester.ghx +++ b/src/gh/tester.ghx @@ -49,10 +49,10 @@ - 284 - -384 + 320 + 6 - 1.7647059 + 0.25101504 @@ -68,9 +68,11 @@ - + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py F:\diffCheck\src\gh\diffCheck\diffCheck_app.py + not_found + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py F:\diffCheck\src\gh\diffCheck\diffCheck\diffCheck_app.py F:\diffCheck\src\gh\diffCheck\diffCheck\test.py @@ -102,9 +104,9 @@ - 44 + 52 - + c9b2d725-6f87-4b07-af90-bd9aefef68eb @@ -706,10 +708,11 @@ - + Allows for customized geometry previews true 6f2c8a4b-d787-4606-9170-900f972641c6 + true Custom Preview Preview @@ -730,10 +733,11 @@ - + Geometry to preview true 43f69636-7c49-4472-9329-bd25ec713d12 + true Geometry G false @@ -758,9 +762,10 @@ - + The material override e22d7711-ceb9-48df-9270-b376fcd13ae6 + true Material M false @@ -825,10 +830,11 @@ - + Allows for customized geometry previews true 53c99f0b-499f-4471-9227-acc96558bfea + true Custom Preview Preview @@ -849,10 +855,11 @@ - + Geometry to preview true 525f46ad-33c4-44dc-8862-35b0ddce4d1d + true Geometry G false @@ -877,9 +884,10 @@ - + The material override 2e7559ef-c4d5-4ffe-a304-c34c078e5af0 + true Material M false @@ -944,9 +952,10 @@ - + Colour (palette) swatch b14c32be-c541-4fae-93c2-449d7543457e + true Colour Swatch Swatch false @@ -1125,9 +1134,10 @@ - + Colour (palette) swatch fc5dba97-2c1a-4749-9c61-3f88abff00ff + true Colour Swatch Swatch false @@ -1280,9 +1290,10 @@ - + Colour (palette) swatch 83adf7c8-580d-4af6-a713-84bf5f8bd2d3 + true Colour Swatch Swatch false @@ -3896,11 +3907,12 @@ - + Button object with two values False True ef4234f1-74d1-42d5-8449-ae68033cb1a1 + true Button false @@ -3928,10 +3940,11 @@ - + Contains a collection of Breps (Boundary REPresentations) true 07b41f33-b1e8-491e-82ae-3da0f5326222 + true Brep Brep false @@ -3983,11 +3996,12 @@ - + Button object with two values False True d89a87be-095f-41ba-bcfa-14a27b69959f + true Button dump! false @@ -4015,11 +4029,12 @@ - + Contains a collection of file paths false All files|*.* 78f00f3a-c6ac-40ac-9725-ad949c6e7593 + true File Path Path false @@ -4072,9 +4087,10 @@ - + A panel for custom notes and text values c4486e03-f65b-4cbb-aaea-81fdbdcd7cf0 + true Panel false @@ -4124,9 +4140,10 @@ - + A panel for custom notes and text values f98c6a9b-86ca-429d-8692-dcc245c0e6e5 + true Panel false @@ -4177,14 +4194,15 @@ - - This allows to run the current active cpython file from vscode to grasshopper. + + true 2 - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABhmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTtIw1AUhv+mSkUqDhZ84JChCoIFURFHiWIRLJS2QqsOJjd9QZOGJMXFUXAtOPhYrDq4OOvq4CoIgg8QZwcnRRcp8dyk0CJU8MDlfvz3/j/nngsItRLTrI4JQNNtMxGVxHRmVQy8wodB9EPAmMwsI5ZcTKFtfd3Tbaq7CM/C/6pHzVoM8InEc8wwbeIN4plN2+C8TxxiBVklPiceN6lB4keuKx6/cc67LPDMkJlKzBOHiMV8CystzAqmRjxNHFY1nfKFtMcq5y3OWqnCGn3yFwaz+kqS67SGEcUSYohDhIIKiijBRoR2nRQLCTqX2viHXH+cXAq5imDkWEAZGmTXD/4Hv2dr5aYmvaSgBHS+OM7HCBDYBepVx/k+dpz6CeB/Bq70pr9cA2Y/Sa82tfAR0LsNXFw3NWUPuNwBBp4M2ZRdyU9LyOWA9zP6pgzQdwt0r3lza5zj9AFI0ayWb4CDQ2A0T9nrbd7d1Tq3P++484P0A3o2cqrMnZbPAAAACXBIWXMAAAsRAAALEQF/ZF+RAAAAB3RJTUUH6AEZFwkM569AfQAABNpJREFUSEu9kntMU3cYhguoOOZ1ujmFXqQtBcEpIwoTxOGQolLwUp24OFS0sEqh0oIV0CIg1FLKsbTlNooFKhRF8TajziW6zYFxcckW9bhlm9uiLk6nAyuWy7tTc0iI4w9l2Z7k++/7nveX9xzGfw+LWMhgV4hd48Y2iN1ZBvEoFiH2ZOrFXkydeJzPvsn05ghhmxIZnCq4xo1TCXe2GaPZJniyKvAqi8AEps5Eb/4LOJVfDQZ4PAswYizLgHHMckxi6vqmeJfMpjdHCNscQgUMDAaMoQJeoQLGUwGTfXR43bvkM3pz5LhxzHXuVMAoqp4x7Ap4sfZT9ejxmk8ppnlrEDE142bCxA3k2vHryKSZYnJrcPxS+vTFcGMR09w55keuAFf/Xs/612OKjxZvepdAMF2NFROT8IHv+5CEroZskeiaJC7Cgz5/MTzYRsVg/64PPJFZhqlUwHTvYrBmFGBZsAybw9ZCGr0SyhXLoVobk0Gfvhju/CJPD2GnY7SwE57CDngJL2FCzBeYsuQC/OM/Rdiq45AsWQP5ygSoEpdi94fRDyslc6SWNH9pvVwgtWb7SQ/k8CfRumHY2ithpACD45YyAA9JP3ykPQiQdSNh4zlsS1gFZaIIuZuEKEx5DwZZKKyZAWhUCdC0i5o9fIK2Pcfm7gmMlIF7zwd4b3MiMMOBhdvvQLJ6C+TrV0CVvBz5qTEoTo+CThmBAzlBaNotgK3AD80av97mUt4s2joESX/ZULlr3pD2I1Deg/nKLiQmN0O2Xoys5HjsksaiUB6Nfcp3UZ67ANX5IThYRMn38dFSxoed4J+lrTRbngio1zuHyid9NABeei+CFQ5EZ91FcsZZyBTtUGUfRGFuLXRqAuaCEtQX51GvlqCllBLr+Wg18HDIzIO9xnc5baeQ9J0YKncNU9aPOYoeLNzZhXWZV5CiOI3MHW3Iy21AsboSRIEe1ZpCNGh3okUXjhaCkhspeRUPh2u5aLNwb1isM0a7Xi98Xj49rR8CuRPvqBxYtuNXbFKcR5rqBLLz7MjPt0BbZIRRo0WdLh82fRLs+/k4ZKLk1ZT4Yy6O1FPT6IujzTMzqT/HGUv1nzp0eOnO1JAsR+rinPuZiYrOPonqLOS57chRH8TevbUo01D16IrRSOSgwxCJK6ZgXK2ZjW/rZuGa1Q+kjYfvW7i40ep7ne5oeNbIL6mTsi9gW95pKNVtUBc1QKOpwn5dGarLC3GxYiN+Mkfgds183LcEo8sahB6bP3rtfAwc5qK3nbORVv0TUdpF1jplx+OtueeRvvskVIV2FJTUQ1tqgpHQotm4EzeMi3GrKhx36+bhgXUuum2B6LEL0NfGQ/8x38u0anhWbe/Yu0H1OZm66wyZuecomVfSRBZpa0h9OUGaK4rJL43rcbN6EX6xhOF3awge2mbjcWsAnrb5oe84F49PcUJp1ctz2SCM+64qGj/URuK3A6G4Z5uLR/YgONoEcB7jwXlqZiO9+vKcIaLHfG2KJa/VLMaPlnDcts3DHy1z8NfhQDxp96Pk3O77Z9gz6PWXp7MiTnG1MhbX66Lwc8MC3GkOwYNDb6GrPQA9J/lwnPbNo1dHRqdJFPVNbYyItEaKbjWFie62vi3680iQqPu4v+jpJzzRg3PssfTq/wGD8Tedsdp6457pjwAAAABJRU5ErkJggg== + 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 08fe15ed-12b6-4c72-a8ba-350c0da17df3 + true true false true @@ -4228,13 +4246,14 @@ - + true Connect a button to open a file dialog to select a cpython file to run. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= f703fbba-ff07-4709-8112-cd955660e259 + true btn btn true @@ -4263,14 +4282,15 @@ - + 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 - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 0484038e-7609-494e-abc2-e4c58b9763d1 + true packages_2_reload packages_2_reload true @@ -4279,7 +4299,7 @@ f98c6a9b-86ca-429d-8692-dcc245c0e6e5 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 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -4299,13 +4319,14 @@ - + true - Converts to collection of text fragments + rhinoscriptsyntax geometry - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 23c12915-418c-45d4-8a9f-82667941634f + true i_export_dir i_export_dir true @@ -4314,7 +4335,7 @@ 78f00f3a-c6ac-40ac-9725-ad949c6e7593 1 - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -4334,14 +4355,15 @@ - + 1 true A generic x input. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== 770c2c41-936b-4563-8085-69258fb43fe4 + true i_breps i_breps true @@ -4370,13 +4392,14 @@ - + true - Converts to collection of text fragments + rhinoscriptsyntax geometry - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAO8SURBVEhL1VVLLJxhFB3ERMT7zXgb71e8X/GId2IhQZTuJGwktjaNxqpYNAQbsWBHiDRsbNgIC4lWYiUs7LSVtLqY6UNNTu+58/9Caaurpie5md/85px7z733+yz/CnYPD4/P8om/iCcSj4OPj8/r+fl57O3tYWdnB9vb29jc3MTa2hoWFxcxMTGB/v5+tLW1oaqqCqmpqZCE3spPrW6G38DLy6tdfvh9YWEBZWVlGqWlpSguLkZhYSHy8/ORk5ODjIwMJU5KSkJWVhb8/Pwcnp6ezwyaX8IaGBj4YWlpCZ2dnZodo7KyEu3t7TBxcnKipGlpaUhJSdFITk6GCDiFw+amegDe3t4v+vr6rkdHR1FdXY3a2loNPs/NzcHlchkSQHNzM9LT05U8MTFRK5HkvolVrwy6e7BHRUV9nZ6eRkNDgxLX19dr8Pns7AwrKysGPTA5Oak22e12FYiLi0NsbCx7wSqK3JS3IN7vdHR0oLe3V225LTAwMIDj4+M7Nh0dHd0RIHl0dDSCg4NdIvLGoL1BW1hY2Jfu7m5tKj2/bdHy8jKmpqa02aenp4YEUFdXd2MRBcQBxMfHQ6bQIZxP3dTSWMn+XXl5ORicFlOElVDo4uICLS0t+m52dtagB8bGxlQgISEBNpsNkZGRKkJBqeKjcPtZpPPPQ0NDv5CcI8hRJBGzpdDQ0JDugjmmXV1dBj1wcHCgzaX/MTExiIiIQEhIiIrKMxf1pUWUPmVmZupsMyhSUFCAoqIijY2NDQwPD+t35g6cn58bEtBKTf/Dw8PZAxXKy8vjdn+iwEsZL2dubi5MIT6TjBU4HA6D6mGMjIxo9rRHnEBQUJDySFXuCugT/WKpnAoGlyg7O1szX11d1Wd+x3dcrp6eHoMe2N/fV9+ZPe1hJbRX+urugYGnVqvVwR9z/fnJJTo8PMTg4KA+m+/oL0fz8vJSBa6vr7VaM3tWLRZxF26mSMHZpXdceZKMj48rAQX4N4NVmku1u7ur74mZmRklp3BJSYlL6O7tAVHKs4QEXCITTqdTjwmOIonZo/X1dVxdXRn/4cbW1haampoQEBBA7+9vMiFVvBIfvzFbTsbt4JyzmfSYDaXnpi1CqiMsk3MlNL88iwgbq6DfzJbNM4OktNAkZkNl+uDv76/veTdIH39/mhp4JrPs5OTI8XETJinn3Mxa7gD4+vrqeSVVk/yP9wFhFavecywrKipQU1OjBPS3tbVVM+Whx4ORW83zq7Gx8fE3mgHerz/fuX+Kx9/J/xEslh9QdsIn89F0TQAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== c87fd4ae-11b7-4647-804e-d9cf678a79b3 + true i_assembly_name i_assembly_name true @@ -4385,7 +4408,7 @@ c4486e03-f65b-4cbb-aaea-81fdbdcd7cf0 1 - 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b @@ -4405,13 +4428,14 @@ - + true Converts to collection of boolean values iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC de47b8a3-cb7b-43e4-b958-28f86271d143 + true i_dump i_dump true @@ -4440,13 +4464,14 @@ - + false The redirected standard output of the component scriptsync. - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 99e48b23-64d9-4e2f-859d-62348fa491ae + true stdout stdout false @@ -4474,13 +4499,14 @@ - + false Generic example output of the component - iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC 58680e01-bd51-44b8-bac4-82d9b43f37b0 + true o_xml o_xml false @@ -4508,13 +4534,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== d9399b7b-ece0-4d60-ba8e-0bb8c0bdf01a + true o_joints o_joints false @@ -4542,13 +4569,14 @@ - + false rhinoscriptsyntax geometry iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== 8051ced1-c685-4aac-b373-3da1f25a7345 + true o_sides o_sides false @@ -4580,7 +4608,7 @@ false - from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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:
                                    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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            packages_2_reload: System.Collections.Generic.IList[str],
            i_export_dir: str,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name: str,
            i_dump: bool):
        """ 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(btn)

        # 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 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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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)
 + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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 inspect
import sys


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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 get_reloadable_modules(self):
        """
            Get all the reloadable modules from the sys.modules. It
            make sure to check the module spec and loader to only reload modules 
            that are actually loaded from a file or directory

            :return: The list of reloadable modules.
        """
        BUILTIN_ORIGINS = ['built-in', 'frozen']
        reloadables = []
        for m in sys.modules.values():
            if inspect.ismodule(m):
                spec = getattr(m, "__spec__", None)
                if spec:
                    if spec.origin in BUILTIN_ORIGINS \
                            or isinstance(spec.loader, importlib.machinery.SourcelessFileLoader):
                        continue
                reloadables.append(m)

        return reloadables

    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
                packages_2_reload = self.get_reloadable_modules()
                # 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:
                #                     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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            packages_2_reload: System.Collections.Generic.IList[object],
            i_export_dir,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name,
            i_dump: bool):
        """ 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(btn)

        # 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 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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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 @@ -4596,6 +4624,695 @@ + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + + true + 2 + + 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 + + 6b67286b-4ffe-43c4-921e-806b10a83b8f + true + false + true + script-sync cpython + scsy-cpy + 1 + + false + false + false + + + + + + 236 + 527 + 173 + 124 + + + 351 + 589 + + + + + + 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 + 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. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + f694cce9-2bb5-4c5e-a912-37ca1fe650c9 + btn + btn + true + 0 + true + 37a1fdbe-f895-4bf0-a740-19a73fe2889b + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 238 + 529 + 98 + 20 + + + 288.5 + 539 + + + + + + + + 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 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 1facc5d0-c7a9-4cbb-95f5-7d3a7ef123b5 + packages_2_reload + packages_2_reload + true + 1 + true + 0 + 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 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 238 + 549 + 98 + 20 + + + 288.5 + 559 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 6ceb5c7a-499d-4deb-9d2c-d1a955effa73 + i_export_dir + i_export_dir + true + 0 + true + bee0b3ef-7bf0-49f6-8e1d-71c7765756d0 + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 238 + 569 + 98 + 20 + + + 288.5 + 579 + + + + + + + + 1 + true + A generic x input. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + e86775bd-fb57-4402-a56b-9a1fa88b3782 + i_breps + i_breps + true + 1 + true + a126a588-53d2-4d08-977f-68deff6a42c2 + 1 + A generic x input. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 238 + 589 + 98 + 20 + + + 288.5 + 599 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 99293e71-3a24-4bb0-a208-4748b642d47c + i_assembly_name + i_assembly_name + true + 0 + true + aedebb31-f342-420e-ac55-d80e788a157f + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 238 + 609 + 98 + 20 + + + 288.5 + 619 + + + + + + + + true + Converts to collection of boolean values + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 5d5ec1f4-2789-47cb-b7e0-5f1023ada8b4 + i_dump + i_dump + true + 0 + true + 51a09241-6321-4d8b-bfc9-536b009c6410 + 1 + + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 238 + 629 + 98 + 20 + + + 288.5 + 639 + + + + + + + + false + The redirected standard output of the component scriptsync. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + eba563ee-7094-4907-b35a-ee3a9d076495 + stdout + stdout + false + 0 + true + 0 + The redirected standard output of the component scriptsync. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 366 + 529 + 41 + 60 + + + 386.5 + 559 + + + + + + + + false + Generic example output of the component + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + c98a3826-db80-4996-b56f-4d6ae964153a + a + a + false + 0 + true + 0 + Generic example output of the component + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 366 + 589 + 41 + 60 + + + 386.5 + 619 + + + + + + + + + + false + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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 inspect
import sys


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            Reload all the modules (local files) in the directory of the script.

            :param directory: The directory of the script.
        """
        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 get_reloadable_packages(self):
        """
            Get all the reloadable modules from the sys.modules. It
            make sure to check the module spec and loader to only reload modules 
            that are actually loaded from a file or directory

            :return: The list of reloadable modules.
        """
        BUILTIN_ORIGINS = ['built-in', 'frozen']
        reloadables = []
        for m in sys.modules.values():
            if inspect.ismodule(m):
                spec = getattr(m, "__spec__", None)
                if spec:
                    if spec.origin in BUILTIN_ORIGINS \
                            or isinstance(spec.loader, importlib.machinery.SourcelessFileLoader):
                        continue
                reloadables.append(m)

        return reloadables

    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
                # reloadables = self.get_reloadable_packages()
                # # if packages_2_reload is not None:
                # #     if packages_2_reload.__len__() != 0:
                # #         for package in packages_2_reload:
                # #             if package in reloadables:
                # #                 importlib.reload(package)
                # for package in packages_2_reload:
                #     if package in reloadables:
                #         importlib.reload(package)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            packages_2_reload: System.Collections.Generic.IList[object],
            i_export_dir,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name,
            i_dump: bool):
        """ 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(btn)

        # 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 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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 37a1fdbe-f895-4bf0-a740-19a73fe2889b + Button + + false + 0 + + + + + + 133 + 510 + 66 + 22 + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + d9f12976-f7f0-40a9-a06e-c4e80b19529d + Panel + + false + 0 + 0 + diffCheck + + + + + + -20 + 551 + 113 + 38 + + 0 + 0 + 0 + + -19.14932 + 551.1913 + + + + + + + 255;213;217;232 + + true + true + false + false + false + true + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + bee0b3ef-7bf0-49f6-8e1d-71c7765756d0 + File Path + Path + false + 0 + + + + + + 135 + 582 + 50 + 24 + + + 160.70218 + 594.44104 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + a126a588-53d2-4d08-977f-68deff6a42c2 + Brep + Brep + false + 0 + + + + + + 136 + 613 + 50 + 24 + + + 161.0756 + 625.8681 + + + + + + 1 + + + + + 1 + {0} + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 51a09241-6321-4d8b-bfc9-536b009c6410 + Button + dump! + false + 0 + + + + + + 88 + 674 + 102 + 22 + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + aedebb31-f342-420e-ac55-d80e788a157f + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 91 + 649 + 102 + 20 + + 0 + 0 + 0 + + 91.80564 + 649.3606 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + dbcb817b-1342-4c31-96a8-a828fd3f41e1 + Panel + + false + 1 + eba563ee-7094-4907-b35a-ee3a9d076495 + 1 + Double click to edit panel content… + + + + + + 509 + 403 + 494 + 251 + + 0 + 0 + 0 + + 509.25073 + 403.22205 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + @@ -4603,7 +5320,7 @@ - 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 + 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 From 8f0d50d90b5960d29fcc4ada3d5e89ee89856dbe Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 21 Apr 2024 10:56:52 +0200 Subject: [PATCH 065/141] FIX: trying to get rid of eigen for conflict --- deps/eigen | 1 - 1 file changed, 1 deletion(-) delete mode 160000 deps/eigen diff --git a/deps/eigen b/deps/eigen deleted file mode 160000 index fcaf03ef..00000000 --- a/deps/eigen +++ /dev/null @@ -1 +0,0 @@ -Subproject commit fcaf03ef7c9accd30133de9e9b4ffa22e35cf241 From 898c165cb8e37a636291f11f4a72bcc5dfa41609 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 21 Apr 2024 11:13:43 +0200 Subject: [PATCH 066/141] FIX: merging fixes for logo --- .github/workflows/gh-build.yml | 31 + README.md | 7 +- assets/diagram/rhdfexporter.drawio | 158 + assets/logo/ViewCapture20240412_103050.png | Bin 0 -> 28584 bytes assets/logo/logo_400_400.png | Bin 13147 -> 0 bytes assets/logo/logo_pixelized.xcf | Bin 0 -> 139049 bytes assets/logo/logo_pixelized_596_618.png | Bin 0 -> 30399 bytes assets/logo/logo_pixelized_64_64.png | Bin 0 -> 14941 bytes assets/logo/logo_pixelized_64_64.xcf | Bin 0 -> 9512 bytes assets/logo/logo_raw.png | Bin 0 -> 40084 bytes assets/logo/logo_text_600_643.png | Bin 32605 -> 0 bytes assets/logo/logomaker.xcf | Bin 125150 -> 0 bytes assets/logo/logomaker_justlogo.xcf | Bin 74299 -> 0 bytes assets/logo/logotests.3dm | Bin 798682 -> 581635 bytes assets/logo/logotests.3dmbak | Bin 0 -> 680797 bytes assets/logo/raw2.png | Bin 12709 -> 0 bytes deps/eigen | 2 +- examples/exporter.ghx | 965 +++ src/gh/components/DF_xml_exporter/code.py | 48 + src/gh/components/DF_xml_exporter/icon.png | Bin 0 -> 5660 bytes .../components/DF_xml_exporter/metadata.json | 92 + src/gh/diffCheck/README.md | 5 + src/gh/diffCheck/diffCheck/__init__.py | 1 + src/gh/diffCheck/diffCheck/df_geometries.py | 311 + .../diffCheck/diffCheck/df_joint_detector.py | 206 + .../diffCheck/diffCheck/df_transformations.py | 135 + src/gh/diffCheck/diffCheck/df_util.py | 139 + src/gh/diffCheck/diffCheck/newmodule.py | 5 + src/gh/diffCheck/diffCheck_app.py | 40 + src/gh/diffCheck/setup.py | 22 + src/gh/tester.ghx | 5328 +++++++++++++++++ src/gh/util/componentizer_cpy.py | 408 ++ 32 files changed, 7896 insertions(+), 7 deletions(-) create mode 100644 .github/workflows/gh-build.yml create mode 100644 assets/diagram/rhdfexporter.drawio create mode 100644 assets/logo/ViewCapture20240412_103050.png delete mode 100644 assets/logo/logo_400_400.png create mode 100644 assets/logo/logo_pixelized.xcf create mode 100644 assets/logo/logo_pixelized_596_618.png create mode 100644 assets/logo/logo_pixelized_64_64.png create mode 100644 assets/logo/logo_pixelized_64_64.xcf create mode 100644 assets/logo/logo_raw.png delete mode 100644 assets/logo/logo_text_600_643.png delete mode 100644 assets/logo/logomaker.xcf delete mode 100644 assets/logo/logomaker_justlogo.xcf create mode 100644 assets/logo/logotests.3dmbak delete mode 100644 assets/logo/raw2.png create mode 100644 examples/exporter.ghx create mode 100644 src/gh/components/DF_xml_exporter/code.py create mode 100644 src/gh/components/DF_xml_exporter/icon.png create mode 100644 src/gh/components/DF_xml_exporter/metadata.json create mode 100644 src/gh/diffCheck/README.md create mode 100644 src/gh/diffCheck/diffCheck/__init__.py create mode 100644 src/gh/diffCheck/diffCheck/df_geometries.py create mode 100644 src/gh/diffCheck/diffCheck/df_joint_detector.py create mode 100644 src/gh/diffCheck/diffCheck/df_transformations.py create mode 100644 src/gh/diffCheck/diffCheck/df_util.py create mode 100644 src/gh/diffCheck/diffCheck/newmodule.py create mode 100644 src/gh/diffCheck/diffCheck_app.py create mode 100644 src/gh/diffCheck/setup.py create mode 100644 src/gh/tester.ghx create mode 100644 src/gh/util/componentizer_cpy.py diff --git a/.github/workflows/gh-build.yml b/.github/workflows/gh-build.yml new file mode 100644 index 00000000..c26103ff --- /dev/null +++ b/.github/workflows/gh-build.yml @@ -0,0 +1,31 @@ +name: gh-build + +on: + push: + branches: ["main"] + pull_request: + branches: ["main"] + +jobs: + build_ghuser_components: + runs-on: windows-latest + name: Build components + steps: + - uses: actions/checkout@v2 + - uses: NuGet/setup-nuget@v1.0.5 + + - name: Install CPython and pythonnet package + run: | + choco install python --version=3.9.10 + python -m pip install pythonnet==3.0.3 + + - uses: compas-dev/compas-actions.ghpython_components@v5 + with: + source: src/gh/components + target: build + interpreter: cpython + + - uses: actions/upload-artifact@v2 + with: + name: ghuser-components + path: build \ No newline at end of file diff --git a/README.md b/README.md index 1e17f87e..24144c8f 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,10 @@

- +

- ## Roadmap diff --git a/assets/diagram/rhdfexporter.drawio b/assets/diagram/rhdfexporter.drawio new file mode 100644 index 00000000..a986f367 --- /dev/null +++ b/assets/diagram/rhdfexporter.drawio @@ -0,0 +1,158 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/logo/ViewCapture20240412_103050.png b/assets/logo/ViewCapture20240412_103050.png new file mode 100644 index 0000000000000000000000000000000000000000..4ed5bf340f844a74293b6e4a9afc53a9c3ff581d GIT binary patch literal 28584 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 LNqGeLXe$3d6S|-c literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_596_618.png b/assets/logo/logo_pixelized_596_618.png new file mode 100644 index 0000000000000000000000000000000000000000..5da32d426e85672b4a6ad33fe07aa31cbdc84cdc GIT binary patch literal 30399 zcmV(xK zaB^>EX>4U6ba`-PAZ2)IW&i+q+NHf|lI6Ivb@!j6ctapSw8H^G&`dMX@U<2gk=48_ zlig31m6cg>ct{ZNW^aeP<5>Uq|MedK^FRL++S%KYa&4uTa`I2=smH-z+WGx6_J6~f z_J8+3Ii2z6r~ml*QO3^)ksn?Bd3_(W^8FcpfBy4@-#^3PZ~1RGYV+rV`=1~5^!*vz zzi#yNpvw_Cgy-i*{pUtk{5}XjHyGb*ou#+>_gA>r_vg>|ziHt2;eT4+WASF+XaD;D zRGGae^PDTjb%pEXzt{Ka6)%6M;~M-W@!xPYF7%f_3E$6uM#6;rr+NDGPiI80Lrwqj zqJON)TmJm?A3y*7+wt$!O7Z8C>tB;x{`~nLe}07gpI2p1{okIP+RxwOKYw1Xl)n-E zYxe#9zE6AiJM$JJ6{foUywvZj?7wl{%_DqtI~ZCyE59?hsQXvvS3{~NqVSyay!kal z50T}1LkdqA;SFp5Im2X#DXt?{{u1Mi*ZyI(3po~yCQb1!?k;-9gE z{n&oaV?V9&7WYbdVg0je z{Iu5JTLjHXcFkC@c%;CJSC;^Rj;`6+LQ2tBHu5~}}lf#o+dfW4kvzHd1I{S6El>4)uC!MdiFL@mG>G$mAnOMp7mNm{gc;K_* zU9M1a$9z_lDW5(pvG@p2zH6NIt;}i*>&~kuK*a3zzTR4{yS_ct`IMVixtV*URkXR>RTptXTeBZ$)O@YvnfIxma1`QhWSf*zw5}A!Dzn&vqeRb*1?Gm9ep_m9T+jw8?EJHGAU z84JOFKnj?@&dVduXW8EvIpcEtcDoi6bH5K)^{0>LL=gL$?|RN&=l$HrUE3_r>Q5Xa zS605vs~`h;zP;m8xM{d+RpQrms}*D6;=pIq*UAiUDRM`=U2(i*W)@BX|83s4TkD!*wpR<$i)R8>NmeCB|ayT{2z z=vzsOaYd@oH`X+wS!DIsvv#1+V zOdy2ue4hsyz*xmluy4Fd#~$pbpRoXNGQx?v^ap#}%fV_q4|cU+#SoNGF{BM+Q`0Ee zAqH`w)hVnK)0;bU&G5u!D7BXRtpV489PN)!9S&FDDVLs>ul~G#<9S)ogtF%M)}a0T z|3V<*%-UEM3V1cfaSzl5e{t5py0OFqacaD3VLJH-eOZBzb3xGe0C{DM72qQ1R`7|~ z?U@f&6t4&}T_a9hCI5&i?}uv_w&~>GjLNow9a|4(=AAw8u#5>sYw)bNmNy;Vq)s%s zH2*3U`9J#e_)i}&TYIK)RimczM)2wslHTpzsXe(iFm*VEUD3baoV)&VHNAD1^xRyOrAU#L*PTigi6gDV{T zcc4Hh%K2jP5ZJj^2`?VhXD?(7QOAq$0%%gl2wZ+Sz?*&sccXh5Xn@T{al+@I(Bm|@ zbqKd^W8evVQp;`_m~@3%-bUpfzD%kiaK*&y2$x%!Hw7`wnZ344W98aSn9rzp)L$cUzQIZhL@_VqwH;eOyx>HJy(Bf;N*! z4V&pHs2{SC^!FLX!$_5S;pdBn?EX&7-&`;_{>4&XcSkJ7Qg= zU|N5G56 zaNYoAtQ&~tctCs12|fnu5^-VJsxUD#yb1z=$^~38Km~!+96$YK2#Ea5cYoupnp7n8 z04Nl^^z#6=#693d(87GNLx|_w_%Yr>R0o`7P1>3_--dW%)Ubmu%aO-ojxHR^dT#vYY?DX7!wN_X2s(^ z+R%|$!yE4aeHdEnTV|OzCB}}J zf|Fhr7#A48w%4@<#|w*^Yly`UvO*T9Yz7x8K6 z3nan%OS;jTl2u zvYhZ4u#O2Gu*g#JLKub{FROP0BL*ZS-v>+x1F{{XFMj&nH_qnR5iL+Xjsm^Jw6P`_ z-EANQ(h4DiP^z>^6A?P@_KCtin2b4=*3O> zu3tY&>VnnkFaQHdsECe-?Gk~n5Q;g$PccXE!RO9Ea{wxD%0%E2!V}u2$ zGaTX1*ZK7P{XVR(0cf@#dyn_r)+dV>v%@->qU9jV+U(GQ>J%9$>Kszm zJqC8(jSB`pTzGu_SifHGo+nJ`g+Vh<2>em7_$(O=hFO~z6VBAIjJ#pMw#&>QdaN42 zVFDT^Z^)WQL)R=);_F3pa^S8brX5+qt}|(GhbL$z{gB=O+FbZW%+dk0xwnVY!KF>zcsO7J_IC2{<-^xwxIVI?SgrloTN#^R zV<5tv`8LaMDAljCjDRi>|8)+)=Dq@yjhbR|$E*+E#y^U?pPYbFV1AJJCVZ_Qcv+0h zh(J~h9=yDQ7+F}18BkKX_9D1fdoaZ~Xj~aXT&M}Akr9A}s-g~qlrffo>q23TOd3iF z^}7KV;1f_vK&Qe4(Z+T{PqD?kCuaP49WyZSnD}w9p5SZ&k0p9cNvP1b3C_lK^ZlV4 z0zsS~(_<~-!XiWUfNe}CChNFomMt;}-6NMQOisbWV%8WWIOWwxf;x*_4Ss?49GFQc=0`xu*r479T+7)&_&`Prh9kg{}Jzg zBQq%#3>p?sKU|-!A)pLkDhy_w2XBip*N2TFvwCi=HpU0ffZa739RVUe=k3GLxp~ic zA`O>u*gCQ7y*3;qU<$Q)*Zz#3dCQ1l;pX2xVbKY%hnap@glB>7uut$O_I{d zXlBG^dq!0MO#|qU=L(`X=w#~dFhSW?LJtgi;c-~#j%Ka<$p`^6WfB>7~ts^M)`f+rU3peNUjVC@YKpVG_U(z@O7A~^EqU+02M&VgI(p>(7)dBiL4Z; z^6KDVqy-y{C4+7Sq;o$5&ha$e_x%8dp96@?&=F!*?8NsuE&FRx_gGovj5{^riUY3L z7DSNge13+FBHT?obU5yqQU^L=7`&t2EB3uz1gnyy?u}U_@j($2#2qtr=`Ew)QIpQJ zfY{1gQ^W>t&$xjg79Y2o9{|Xo0gLjWkN5~UCZPT20rBSr=P`Z4dBGkF7wR4th#HI& z(MR?o|q7VHkdesbm8M^G zN*EJFE1$;>fLy3kb+_o^4b`&0eFMJ%PYnzVX2WVhNbvg0-F3A)YzHfxGgpVv)@JjT85$!9Pt{oYLZi!km?ChTEAvhGTk30G{ z2yg=<|G$&N2+(cUfss40EKqGc4a9K1#<0u_c`hBe-g#b(DFMAeK;W(xZu3EK+Te+D z!2r^T2qX*m6c{`6gOS8X!C)&K{5O!wd+jXsS9(f%k<*U>rs&3y!l#fi2?8_jU7*K<%ev zgy5^~9G}0g#Zbe6acVE_{>K~FE^s&@GE61n`@S=vZK!uw&e4g9bQ(rw6d>4+b&HM3 zIJjUwQ~BCXI|butm8ry78oG3^ksC0qIhr&E)RFlNOxa>`@z$54Hg?~i@|dR z?iYc?4k2(D03+M9yJa z{O~OoUZ6ngFe?$#`&_52wMcexHU^gaEvcDM3Nt>?JwS98JuyW9@B}Lhtid~`5l^_- z4FEc^^~mg$ofUpO_oxpb2lP(#iJgJClyVfvF7XGZH!wy_(kj_%6`2pFoLhxPiH;6>zS<&^(FQX|;DI5ofvs@7k>DrN&8zNT(OopN1mIYD1E{!MhcrNB+ zLzQnA7_40v>eJJSkt!ip*d3f|x>eHmHIOMl1Q6t!DMmd{>aT7AqyTKm=oMt0w+>q& z(ty`6%MpB^;Pll!k!Oixz;lOC1xIRp8mux5$Fuxy`7t_8#F}OO1ttJ>Mql7$a4f_R z2U->E0)|9gSb*Wy_8h1-v&o$$X=rcqu>oP`LHG$n!&sHJ9#a^wIROfb+3FPs*&8k$ zKVf*v0K4BYj?7vN_iE6)4tN+wXe)kWM+LXP)42eBS>(KqfkHCQJ|wMA#}M%17&dod zx~K;Jo4(N(Q~p{%7Y3|vRFOp$ee}{;{@6cUffI2D6YCCf_4c{$DFFc2 z3ls0mE&sv(z^H0EFn)87I_`(~nwXac0I2u{Xn80Rmjg)$M)sINMcne5+)9EhN$vhV zUL)!mqf3DrU_m6y!?@N_emGD7~2hX=WT`_2Po>t@<*6qFTB?pU&Dd-R2e_&pR; z8OlN#=pzrlGXxr_z)DXo_I)4wVO)w3d{1Mh0PBtr9cZAL23&K8MAJ|KY^*9KS3u(y zKsH;2={wMKtZ3SMJUBXLoM|_PjQNjd!la7nP2c6rdc;O!44%fUr{dNc3=~s;aQ)TX zXyONRy^@Z?NfJw0{-ER*W&-l2n?`}I}WHtzW&_*1hq^Y^konvvbBnA_B z$(BUe4|EVq<0jw@L`G_i5&nGq=69N=FbhB{LarfV_^uPV@blYr1>SQ>c5}fSA)5(n zpYte+Kf=-7SjMLm`7Ivf;8EQqrVeblQVOSIi&zQK|I}kLyLb_RvPn>v9K@p%^>LtEmGh@2%NFWp;!bwT+cN!Tebi&7^Z`@$TJEuw>F4prn0 z2Mqwfagdh@ImxUeF)Qj8r?F8tPmCq$-rcHkz||y5-W#wfmbegp!+0nHT%^O(7*Z2D z$8+ZX*G=YC-SPV_0GY&dG34KSp!B>tZw&GQJst%EKB`F*&Vm{*Q^ew5FveV z<=DhtPYl*yL&E6Z^#-^cII8pK8g&5SH_;^RaU&_4!I=z+!$Us`qlEolhIkmb84V{_ z7#RieVXnMQF;rIo(B>C__6_(W4|r8j1I~ZENJZQ+s`MB5#gUW=#y-saSh|=D&~5R{9cBUu_8=4W>vHwfANSZDB41y z@ojP?Sb!BPQCA3<2ZAF{OlO-1L?d65OJ86Mo;~530iniwO94je$I#T1SK2RX7Vfw^ z1P~vDA7qgODiV$pgNlUS0Z~EC0IFL{-~2WGq-r$AC%iF?1)_hI!o8s-DlknVswG!nfr?l^d7fE5rKl#chsg277{1eROj_1ZNMuVJ<&5Y23lr>xNP6#~nOJ!%&; zpbLuPbUz6tP9od$4eoF}H`X|UE(bKeV(=US14RytsYS5NHqvt>EFZ2CPwTeTE4($% z>$daM0~NPQ#5wxzn6OZ$5vhleFd-#&y7ZBcyMsB)gQE8D;({}LAqNy6a>>k4@*C%V`W9<@HS<2EqfDGeYvN#WnMR z5V+?IJ`9Lo$Bf`vKp{qBEMfwhz|0UN+%ZIvd4N_XW_$tyY5)?L!{Z)R*?Yf3H;W43 zMXsIy1LH&aXB;NVb_kGhKi>0pJ#)sSVkI$`05VwICSAjF(qY>=8C&n7?2|6lvLmmChwVo2Kx0IPDvb z83;>$1@dBUpJwL!iTQ~0&jsqsHA2F1W6y-E0zMD`6lesjA|Cq2Pair;&4Ps#*bT!4 z#YFvh236_ZFbR|GMsUyF9gGY-tzfBbp3(3Mb4bSv*S%nF+u}gOKn3S)317Ah1!GE< zTS$fj&Tz?7{8Utm8SD83|A|uT@iW?Y7sxRWcmPvSKN&@4gK^e+Ps9P_y~iUh{06j# z12ucXbAV8~sSI~(JtIzaiAa}eZeQB0BQEft+X3TDq`fiyUSL*O#Hd)p(D$gl2Lo;( z=j}Hh&`ld~WPC#Zq!uGzVMNh%nLjZ5G{H;c9}?n-8l`dJa_4f$n0)RO3SfS9L&LmM zG`0-$|CqYTR<}(vu0n+0ravOU3QM+-tcv-+5HRd zc!2d;T$Bc&@$x@Ax$jM^R^9_SllH9qB6SDa9jKeOU~iBU_7X38bnTA7+JSTj(lbDHjF=Gsg7IHg!OTZ|-j{E>@eLIE!lYo5F|}aZfEfhZKL}m`rR=a3 zv#Y;6z-Fv8Oeq1h9v}!HBAIkDCz3TgW>%Sh5-%1Wkbw7ZC_HegV1dpT2lJlVBaoyC zZb+DJBus9%3{ql@VG1xxbmTSl?n;Og5SS-pTV7c%7ivWFQ_ZaFLb0?_O_~uqT8#?< zBF|}I@L#V0lEpAXrrh+GZ@7;FvKcewgT)yAQQcvFBK7N5@^82A5FF!<!m-m?`D zJDBt|3dK`?U!>jj@Or}?9Y+(#vy3pc03t7zl~@LYadvmBDtiJN#xh~^=*|M10^z$z zQ=m2DtmPiSI{App#9MyW2Kw8v(Po>^4ZdnKYhK5Bd!^JXq?VTfN_Kp#rOz z=&d4jh-pTuVfr{}<~Mc;>^U)oy8db69)h_npc5W$n+j>bncj~1*aLUF3L3!V6o9J9 zUEiBF9_5o#mLJv&2g>8+hjU?ubT>Q&H-luyi@|jOtA%Y^5nlzC zNQakT1~XHU&ph03F3*Yae1NTd7%prlHg~}Bv&9<0os$LF2GSIOJPQ=vsM`;#Pb(nd zj`kGu-K#|grsP6!0NU6>Z0|th_yBm&J3oXHRX6Fj;Kp%8V6zWkz7><#T{%3J07>Ks zksS?BG4jRSnd1j7oAnFcSzl_&o-xkjsu)|SfZ?+nmU5ZG4b;FB!I=%1WyJY`SimdX zJAX7)Jkg@MsJO{f+|Iy!atW9N(shlUaLQ5(I#eY%J01tKKEsD8z?DeU7Fu~f#sEx+ z$Q|Cs!bAqr6#t!F*Nt-W4UrbYajp+)#oJxmemRquvAy{kId{9^K7I!q%n*T8;`$iI z#%jYX$nYlX2Q4pSDnNhk_@h(i1(x)CMdd~xc$zDlhN;#)@9#?hn7&9-aU0DG%>D)I z_4<3sn=JIHFG_3V6}KLCBJl}%w5)_d!R&PhrdlN2NBnua9_JqWhur$_B!;7@AK%@P zkw0?;&0>zcW`GgVa@mgiuH|>4@hLbiU*`6TTyc887)<-aP3RR&aam^)eew3#PQrl&VpDA+EzlHzKcp%h?hac{YrQvDAMcZ z&CeBLj?6S9_7?qMl`wn9tAXA{NmijY;aE4`3X$U7u!$df!_!$# zXK0XtxXX8Mjk2s4XjdUMmJi`OA7!#}2jQXOXF(2Qw4uxlV^`m(FhgWs$ zK>+vrJu}$u_XpE}TH%;hOyg&g75As*M9*>VM+K%Wzb3a}Z^F4D7ckMAh%g~Sqz0@ zyMSeipmb^bR*?OA<@ZpBG5SovMp1aV_PPUS-numfKs+JTgTrHF`Lef3Oo&U#$RFl$ zej`5IJux|yF$)ddgeXo5N|M2A%t!m~4`zEDTf>ruTZJ}1U?i+}0#P2OhC|kJjt%$- z&2H$FQBrfh5}@D;MhIC<6Ng6q$==4Olz$|2AO3|U8W>vJP1sJxEXtvH1b`m*Vk%Z> z?yB8psk#@Xa~SZm>@L)0Qqj@>ATn^H8e+VFcXj`!iT`1CDD<+p@RUdzh1c}m*&07+ zpSdYXrQLVD<1bXK)&3S`jTY!SHV*$x0uF}dXxMP7IyVcK^OlLQ!+-2wI$ za4{HK5X%+Ni=jI686T_MF>LS?Ih#A6?$t9j)_+z^8b*Ry0TjBE6VW_DU8rq;{B*Z@ zzZel%sUPPLh)96WxJJB^MV!+CgP38H2K8e)-+^o+ZjexX1Sk=pR&d=rEhpQM>#%BkfzPfCVWi>evAN&(!d}DOibMLHMIb!SvPaAh`_a7J)Dkx%^Tx0Vh z!@E{#m!I%fhq9WSlxJ~jL9t=wYIB1_H;nW`*s!s6?}HQsz`jY3jf9x&T+S(S9|{7` zV;&%5NfUYPKn{bu4>$oP29seOm%*}@O%J#i))Wf3vkWWX4+8!>?1m-zK4%5K&&zdq zfti9EL0eb1Q0QjKd4fI({7`=psMBa%Z(m{FQQn0QHUlvF#({ zrEaX>%xl~hwH9mgjFkNj2MQ=Lf!Tv2j6^6M16cK*x7+!)OGuW8V#%Sm_lLNi>oFMw zu-4Gu!Sutf910^*G!AQ0G4_MSwdl?&`Z3QZ7$S|2*>I1L%2cR6%-YbUxz}tP3?rbM z4!`Icv=?1|Vh$atyddwpU_M{p81ldcFQ*iN2e+koet|k;NzCT$W?r&>E#X=67plXt zob`*_tO`5A{b0!BxJ~M^0TQcRlQoW5L_9A@=Y+>Lg@+o%@i289p}1{y~mx9 zbDF<9V#fwBBHRAqAI{xZ$^u?HGc;TUW0ye3U~vvMygjgE%+fu~xCNH}?G?Thy*t0n zWQ%f5WDeJ4cNHK}^E)=$INJSv3E9p1)M54pFL&WiR}Jc(N>OdYwE5^}qQw6oeu^Y1B!iMV<-R|eW=YR+9Gu##};!W*mGQCuAH4lt01k|Fp zb@@HF{|bZmWr90h(dcXiI7N$E-ag#s!%NHi_7{vtrspud{kA4IJ#YY1!(BjQnkGft zYvgpRI%op`-Pj7#X080P#IUF*xYV;Bk+mx(KBn#F6-)+?odm5s$t1YfPCi$ZSa!Qs zg=X9aw`@D9X9G}72d{>?!%$mkqqSWLJa>ZLu4_BUX@t8xEPt7H?t+X1rxTLP!ko9M zd#piv59F)IRCo0bYHCb#8kneNgxx~gu`(1l&K=Ag=E=DwU{9-h8uWT#UKukYxkmQX zSq%HOMb=wJn?P9W`5+GX43TFKyHef~66g&ptd^NuZ%vKq>#>2;c;oW1S@7k!zEI_D z*~tDI+V_f*;S5H|n>AS0&whK?^*Y)@B8NK|uStKVeC?h8VA*LhLv%`Iy7i*FwU)tb ze6ge3b!PaPQcN%~nF<5{7N=*BcINX+z@yyTpt5DfOT)jzGk6|Qbx27c0vw=fLi@Mkg% z!C3C+WNZiDMCv|h8LS>QKhT~=HlBgkM6Cw%cJYx3KlVUDm+seMhc|0ME6@X_#R;N; zlee+|p4nJn8l02ClW^PY51(rd3{ulFOEF*zt!C$U%tTRko?XemlgzVm? z!G&u78xT2E>zseR4f?fTr(fCFxHxD=6M^S}=``ge6(}9EUhE6V+W)>kQ^UeATg6HW z-mQNHLBLPLC~Fu{s@UQK$em4zz1=NarY%h{07yF`fVij->dwN%>J1UAkGOEd?h4h1 zxm^J$QNw`-Bx{o~?N*1rrHgVZ(ArLjCO&9Q&;I)237D77EkEblfg216=1n_%n1MU7 z)A%9P6q;Cp&&4KiEmXYyd8=~()Ma@nPq6YpNAu?HZGzd&?>h2h>X)U>SC7WN@OQg1 zN&_1(X^mU zfURBtz1v04J+ccA2u>duQSd0fET*glx!eGrGItY+kwetyL!9pH#*eyGvq@Gw46DG! zr>RA2r+8cUUqvV(C^Zbg3^@#KKP|wpREUvTjyvt8q~$0hAGX&Su?crs7#G#8i+h?t zV1FyK+IbTT2XC7Uy3>aUNlG5mf9J_r&8ZbE7SO%wJ)ST6} z=4_9~ZPi^#zbr|L{3?gJ%-v3f7&YS;xM>7q=jGOZ?$!*(3v}^JSFkd1!lNQyI_^9I zsEgs?!!jnw5fIEgwT)5x<>f&9-5|}zq0L0yaP7c*7hgqFN=1G?Wdn)B&K3h=;Z7-F zMw67R!8a`J*zgDEuA*F!4I8dK7Sq>iL$S-g2bX0k(5&k8X)Tc-FjBR^;DT+u_Br56 ze_(wlJQH}z9RV0NCd1YPkDyk|Jdk!Cu8s*GSXTt1NMm%)He_@lTAqN3L~5)VgQX8k z_O?X>>R&kGw%_;Qh1*U^vLbH@eJ6+&2D>>iE+>?FqQJAvYfsbV)9$|>rsVOk<0;nQ z`QAVmjDO|FjxhiTfuOr8LaKGL&|&YBo1E-9Tpy{c!AE^M38IceBIrD}5U# z-qmIcR|FQiKX&0<9>9CF!;!tXKsx~^(|bHF`w4b9eQBoS*qBmFZ`xwqgEs3?e$$;H zEG))cw-58Y5fd1Z<#2f(ZkO85Rcz=pK-y-%;^zRQ2`CQ1*ShwT$Cz0NLa~&g?yirB z$YX)@bsd`TY^^!^a0@)I+elEEydN6yo|da(`*_c{^ zOE8Kin3*PQNI2WsFTF(~`;HyCGQIb9gT)&8cek8cS>KA&1$%*74CtnfFh~2nBK1F4 zhygE#YNuO_|C9G^tXq%mG{4pOsKv56|F4+<8fEF$_HY%q;T7B z3}Dim^e@=ab)E~|N86r(V&eLeEi&`2t`AD^9#po8MLULpXJ%V}2Y_5@hs_vxvZC6C zF-8OAPzP7BL6cZ)ZJ=Gd^qM&P8($9u zdyG)L7Au4GZ7pbtcZ1kXE2$ZEu(b$&S(|;^wMlpf|6U!*KsL0NVDSxitbHz41!glk zc}sr9YI1-XpAe#Y zWeYIg>k|%H$!MtRW4n-K3)$zpv%n2<5c_UI%jBCJ^OqY+J7)7*xW%>aVM~Z)2V#)~ znvpC5{V+aL^n>wzDf{z1=-E3gbxUSv152`(PgL%Z-SJwiM3X-c_xo!#!M&Ms5^c%i zc@3tK<0*k2tVaT~F84_p4bI;tV#j&23iio>oX=tY$gs30y$B{O&=fyq)mef>80mik2?p(TZ&h ztO(vX``xwz91Ne76k;AlooKynywxEO0jH zj5Xz;B8v`+h1d2+!P-6Rz=15YZ0yx3U3hd0CRy;kV*8f+3PL|q@wm6u+V*j;5{zZf zjkrLPaUDQrFjB&p+~ujkrl!!oVc$@5nL!ESri%qSkchSm zdw!@D3xzv=qz#JHa8MfO+3W|&VxAdjci8vGSp(t%WUSav0>iB=dtmdrFzm%_cbiIb*Y2g>wyJte zNkr;VU+o3% z^>MwdaxuCg5iwP5>P9gYW^8NB#$&t89S`m!tOLb3C1yMXqfvHdLGvqV8z}cGPM!dN zO1O;3q{Y3Hrm90SFg~RlS~$M_cL)v=%BlB{-5h!KMU+V$l?z?E#08Ljd86sq{xrr*dnyU%H&ACTxGOne1mIQajra`mdA_hV*Yd?fTs{K&~JGHCK z(5d}-ck}G){`pY_FNn5MNzMx{d(#cvjd-{Nhw{#X(BuO3Es3;E$ID{uZZ`(Ij9c5s zN>7om^)bbx7Gml0WBHZGgUn8W}mqL+suck`+=B+IZjhh@~%(aT;s^ejJO$m zX8gkuy1O77iU;l7CM^3Vc9A;wsQ%mn+rb?UyFX2cD=Uwea>BuxwjX$yJzHwM^AF27 zH}ifYsda=fl^*O_S8wy6d^T_hlwiPnng{mW z@ezi0o3s`CErES5s{$A`laG)~PTmhhrMoQi})zEx8vp;q3UQ zX|qtvvg|^ixDk#}y=mX>Lv#~7J*Vl5_HngYMP?561I{yhii9sGcNpe-S$UZF`(diQ zaVi|oF!br61#LHMj{8iPO&|Cj>TV1=Km#oE`G9DPrasneIbyS@!lL~8VSAJAqNU7E zgwP%kT;4qq-E@kWjITh%=J1%aV89G?#lk}&Ak5~y&ucvB4zx;cQLMu-@pGr18VTzF z?8dy6KMybnfx}0o%!smhFqlaH_xmexz$Kit<;A7J~JwWQVlY6sA zRGwcKPqVt*lONxZYBy@^N8+0t>WpWB{X%<>3Ia;)XZCXGl(c3u3gr;*mynwkL`rieS{6NCE7RIlrJAR>w0ns?)WBpl<>GMz;B@zN4tbRU!{!MPRxKd07k+89 zyW>rV#BF%`$nOy4s~velYyq!*m@dQwAN{mrL$M>dwef9#VISFKndxR`_MEZV@r%vY zxjq7xEHBt(!+ezb9$&XF>!q;B-9GhCLtlYk|OO zLR#|z%U`3mk)Z{|FtB~(m2GFsF+J_XjW5rLnjVgri~|4;@9+sSd_SlynpZz`ID(YJCnA8RBa*n*xBgaCln;laIzt0@pQ7KXPWJOcUV(f);@}YiinC7MT!l) zKp^xQP-!Ak1Ox#=N-S_YrT7|^T6gPOb@Y_|IXTqIeT+&$C3OX`H|+LuC#cc zryj+%r}RXL>yNFjkF7{g^)-gpwehC~Or*c&u3X{V@z31PV35PO_-u{J9FWKg7b=jfY zWgh$K)w)gXP{>42ynL9{f>*II&vJj>lDF6)ghp=bm*i>LW?c!D`8DdQ*ZvreJ48V{TT7Bm)c%d}coxa`Z6vT-k_1r&ySw&xaNfSTW^-%B1bu_2YVEDpVOej7AF z`4%ntmGmov(9FEUsO8AotEph*^i;onr|AHHLIBI642D22B?4Q4pKj#2y4kO3d|1eO z^H#x`l_8FR1jt(3R-mYd{(vd9$F5@AqV`rKB%#97CE{rR#Xgt5vKf;En)U?;p?4Q% zH>jvF+$qxh$eG8LvnT|YZ*Odczc9Z;2mk3zNAif0?S}8Zz4eUMS<5MJ`y0`w5_F3T zUk1nS%~7jVAnz++bzR5NlpOD9MgI3}`-Jzs*Y5x9=zU!z+uE4*jXrZP&3WOreM93z z1SQky%gtd#KNuHirkyTsa+m1XOMRJWd#3J^KKwN9AZ}{)lhc>rxfRBjr>&P^Vn%(Q zJftK^mh;4UIpH(T9GylntoSQe!G3l3R?oe?vUJk$FvfeZQX@sFrRd=$4JWn4Vrzx5 zg4tKvfxU?zz>bz>0uQjWazvlcL}+_iF5}r$Uy9@{AFheFmbY$OUWnv=t%w#l$FeFt z&=OeISg7}VQ=L3gM#h9`g``7D00WnWW&_JlCg6^6XR`|8EV&xmgZjtPb` z+fsWogRPIAxng%b%_H=qxjKb2X}oh<{F0OS>$eq-A?_E}8c<(*Zg@CQHw00M*1t^H z#9ft8GM$s0ajuuHb{k|C-XBYE9)W*;{+i5<_ab7o&)003rX|7{>`O01$I8jZ60? zA3R$(^?!}iOlxRa9PfJAIMEk571F0c$>FmU3DQ4({+bD`u(^@r{`Oo9lV#)SXC#Bi zjjW8dDXT|WKQeR%eVwLHwlK*mD{{Wp;(7X&ae?VU&Y(n(auFH%WC14AN|DJGVSx|k z-~+Q?XVGok;gzuWu6vB0U2~2yGHQ;XyX;srW4*q8;IM+BSx6boCAi$|n@(kSQc0DW zTA9`x^FjJ$oD_LJ^1j*yvCALgeexnd%?Yzah3nV628*;P=RH#^k{=u@=!MHP?A<`? zeN_7P)OBoEl@ai^C4&y|*JDBz9=tXPV z$Gbysk{;+V6TEZOS|sWT#293^_g*b^=wT1NQ;pRM$tIagus1r~%efixx1;xE4~N!$Ac(vCAqSC6n6@cLAz?{^rJIz`-(>X^-FtPpG8is% z;yR_*`1EaSZ{0WQqd1p6{;asZEw;VcTVjG_!b$9fBx)+3Os{&V{fRPsBTpO40;XOE zzoq2ocw@#SpZCpOB~6E+wJa&Fq6P~0dTdFhQHj-~#Kngq^_~&3ToMighAcDULA0{e zt$y5>`lzEWob}`0Qg_-nqH`d{w0zD5EAXXh=Ec0FfU8p%5=Q8wBR^kS-sHDX=K&dj zvU#WsAt!lRTDCf@Pv-^?7I?4JnNx7M&~9^nM`LaL)UUG5XuY(VIJo&T+cb=!vIx8kqE+XYZ3R26# z@&44v~qfyqfLy6C1-KU>a>I>GPboHfPv)UBRjp>jxY7Qs_lU)IDA+gl=n% zJi0gRO|Q4@T>q+3trQC9PWBFT=^?C6-_|;IZ>MY>;8-%krjQLl1Jt_~Rqp5!A*8=7K>X zQWv`H@Npwn?v}}V|Ija7Tm=zO_wAZS&s&P)>UB5QZlRYABPPzJ9yRF{vb;el55qQG zRILN$lJ7+q7%+4yywGTh1zObDjaNd6PTQP&7WNNy*!Gu~lua^fdpQcX+-OtgAR~tP zne8JR`_tY0zyz1dn=O`mBgch~u&83ZJ+wk8HqWtv!Z=TQ9+W@GXtApq!!8l zf{!4tFa_(*)Ruq16c;>GPSNz74bX>1W~rvVY6sKFKGdvVvNCdD z5cEY;<{R_gZu#Krk3RI6I4<&ZnsHdMW}Sb|V$jy+78YLkCZWNDHvvmlWw{k}nO`E5s(u>BWcgUYrbKu6&1av8lrwxB+R7S%0U|n;#g&8+6K?X@ z9;3SJ2}3N;lFE?|8Jg!i_r}3>Pk8tyF+QlOKd`5JmOA)-Rx30E5>jr)9QFtqfY{I}1!6n?(7J z2t;|_R?yN3`f7=-VYrXTAI9TK?=)@>LS7`L(Z~=z(S!rh^9QH%Fs11tSArCD+Iv^P zQnd{E#37zB+CxH}rLG%muY2OFV4TQ}4r;(a>d{0*Slf~1WqSL$ut_Zm*9LzVB?n<1 z;?P09vremJvWVk|KgFa)a!-sM2ln)`aoRA2oWfsd< z8Fjvl0x6T^RI<}7A8zTu$=(1*)P2X0It>y(-#h!#h~js+BZTlkp2S8dy@>6zC{D#% z@sP@=whE2kVlQx@yx+v0d1!WAv7} zbR5+gq>EwZX_fzKFpO?aXeu_kj&P`hdc9vU_I1#3zjzVAD8^#97 zUyocXyjgeHGTonAHasqps&>NF%0v6Xkav)P!_jeB;}e>_X0SW1wU^Y1^1P0%jwuY+ z+0}+K(~=9bR7zULJfb|=n~MW6+#3emALQvz%yF`3&ELN)?5Gy!5JLKp8O$J#ci33c zc97rc7hOtso5x~ADzEq*_3jlM3( zaQ0%-Smbrb9|{L0z?4e2IjTT&CpLTM;h^;FW)`;o9 zy_Np!5`lnW&`m1lj_4?4f!JdnVQ=lhHSw^2{V1m%a^%(YAg%LR%;^3!aJ!djX}~w7 zq5Py}bU6Z7IdA=Zpp#eYjG}71Cw`u_?v!E%QR?u_iJJhWQ8P;we7ldOiSg(kH2d_y zw2s;tej(M5?G?}VD?{4$hD2GrFSZf*dk1w}%SLM!Lvq3oj>TA7xM{@Uc4zB7~ElG*H!nmgXOuV%Hz?|i)HMmH*e+0 zm&wk~d=Wel$jjGuMCYN1{^<7OD`A{0k<>*Jag4;x_qqAH6#bb0YZG-r9@e6AHnH`G zbm;b|8|xQrXCACvVZe^f@+egk)x6^<<;ohRk7Z7NVSNBkbh`C!_FZRkT$^{QY|FLB zSMKR3+J4&qfVW(va`S!p)SFs~dUbv&jnn+>VUEJ3VnQbc7f(2=-jHhIC=?NTS}L18 zE@)4DQUi|ZiR-+bDHkNm9)0QfS*T$_fVi+KqU)+y^b1--sNbhWfsYrS*wcrfUVe2c z`0IMz_7~4mTPv5h+J_qaBRK}PI2i&fFQwTI3^(G2WcO?mYGb>XjAv?F1g1;k*yZ-3 zaRFhoas1>x@d~xIPee{WKKBiAD0uIJuljHd{f1LO-p$g|2_+p~|HJMjZuF;5?>(p1 zWU=h!3CAF}v4}MaJ<81`!#-5vF|bRZ2Ljj)@Rs&|t(v)-X82338TPS#y>T0fn43meK}mqf}sah^uH9m;qYH&<1U9BL_XJtaM1x zOCC_*2y?UI^Kx`>a+UXjoc*p>9ys3_7Cp=NUBt~Ea`u+C9-j)*1;!^SA}Im}sd*th z#Lp@n;!|{i+RE#zs{c>{e1n{|b8|zNG*&Xw=( z>^1~=-0%ATB>mI(@4|qTwzj+~(#Cz~p_;0Yvpe?6Lyl-nvk>NBH%wp^c<|*Y>_UGK&T^}ph!>G zKQ0*}9AO4-Ry(kX$%siv$cc$dOMxZC#Kgt^5HfXAfKDqQ zbP$eKaF{5{3I6?-or#eL+yS7q+KE&^^Y?MU8+jEMn3WsS#Sn>ffSld2mTyPp@0YcK zgo0YRS*cpN!GNcM#U7cSYK|d0M%^F2eyF z0jz)k{f-si#UFF{%b%_Bw1e$T5C9nnED8DpGO4qoKb#faVT_;NDvJIc9*W-uc2Nv) z-*008bpcE$`a2c=z-xze{)5MldH4@L0Z{$lhx}Xk{ui$Q!u4+<@NWtKH@f}{*T03p zza{+N==#gxI`l^~1#l zVs=daQku2EUfWAmMK4ZGm89xmly5;4Kt47%iapKHgqfK>&FN-iRg7mki-jp9IfVrL zCFMYjj(iE)<6g!5KsymXUF=zXot$`V<;W{+O0w@lfE{^bB`&{A#d36@*^G|PQg06( zC$NP*0~?+H<^A73yM}%a{~X$p+;xDDognVz#7vS_Kg3Oy^whY$Ynka|?3iq}BMVKZ z_4#Z^e�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 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_64_64.png b/assets/logo/logo_pixelized_64_64.png new file mode 100644 index 0000000000000000000000000000000000000000..9c63053ccaa7e005b1a44e4192a1e82d78d3d8d0 GIT binary patch literal 14941 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 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_64_64.xcf b/assets/logo/logo_pixelized_64_64.xcf new file mode 100644 index 0000000000000000000000000000000000000000..00cc168c84315742d444abc3f6ddf6b02b0b3654 GIT binary patch literal 9512 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 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_raw.png b/assets/logo/logo_raw.png new file mode 100644 index 0000000000000000000000000000000000000000..87292a01ac36a273cef182e4c1123b295ee2c68c GIT binary patch literal 40084 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

(bJ;&zT#$nC4q;)KYLhd7*UztZA|& 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 R!$0BgNPBn`{`RBr{{eMc>zM!m diff --git a/assets/logo/logomaker_justlogo.xcf b/assets/logo/logomaker_justlogo.xcf deleted file mode 100644 index 4eec8810de7af2ef1216794aa51623804fd51cc5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 74299 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

6URO23mHp6$# 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 diff --git a/assets/logo/logotests.3dm b/assets/logo/logotests.3dm index 24a0c052c08906c72dd7e2f481c8e22739b929d4..4a19bf17801d14e58550451ab165d4069822ede7 100644 GIT binary patch literal 581635 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%0DPZGfYhrwnFBr3Cv%2^+kWsry|!FhX>9#xrfmK0 zixS}I(w@+-C;`^n`*Qc!as;f#|A)P+fQzDe|A%5H*!n8i1-96-A|O(BE23g|A{K`& zA{L0EqGDsbb^yxRjjb5io#<;9|DD}^_IBrXj@|R{e*QnVeq?sOGyBXl@ttRC_q4?V zPja{;xS~11o!qOM3+DvbLwt6tjZQ9(EC82nm1s^NdmUbNt!trhnaBv|UT(AZz^@;aZP4`ZA z*KjV;3VdGku*b_&tlkAAtbo;&<^^Y;_4QcU_N~M5J1gQKWl5K41qwd!ysp3sfN(xr z0AMbJgNp@|SCG_fOn44k8A_>|FOh5ow29cBKD1h|6@cC!Qq!>lhq`@vZHN_UO|Omi zWtQMos^d337n`kswpQTIYz3esc-L$ND7Gy0tOk*+fUMOZJD*dThNuQ2a*VwT*Y2Y;*kPuJ%_P zJ64%=rBSIjj{n$JJkz%B8^<}-ZMK)o3Ht-|o9Kl2ocsh%egY@oF<MPITu-P?a)laY&lETK!$ z!XmKsfp??b6R01P@~p1u9ids75aQ-

EolIo9kUp-bSt?tz<=XLtk8K^FX=%vGLs{ubwTL?4GjsT_?Gp zjRfNton{z^p)@%i@mLD{P)P6y?gu<=cTaFUz2-(M2;1mTC`{?}{Ngi!IlzJh@gV}K z(#JyzQxHYY@epxw$T+}q&9`Dn*DcGNPAlkd_pJLJz9B-QX}LWfKbrDj>WjLf2h#jN{u2EsQ=+lNYBUN~0_Rr(1H~NnCkSYL#t6 zuH?Q2W>DF2_uo@9Fb7PLocLS2eSM!?wn})U$~(oPR7&?(R}z2F;U7>Sy6Eb8#NKHu zfyUsN5>yO2Y^mO-xjm#z_NM!q-EB}U$YL6L3^BVYbF>$|hC7%({zV^=s;Dl=oEZ}Q zL2=cpR8=|p1tdfp^naaas_IjPu5%B6gi|%#5rli)DHNZ%XkB2$0J<=E@UVMq1QCiL z5IN4tv+QZN;~qinqI3On&EuxBeAQcnBBTapP$L(vKV6RHJlkLCedd?z{9&uN_|3F; zM>&ux$0{27_l~d&>HNQ3j&C@|q4s!(yO+}*Q=l^F`o72A^EFFjwJ;2|$Ctak!jC4` zagRA=b6g$iksl?8R+!NTmC%7{w8C8TM%z@Z2wBUO${HDSM7;y!|X`^q{}IW%V?>uG%*ixYHYqA*8U0g!Fk!n27_~l zI8(TvFC6k35hn>8$QbxZuKal2I_4N(ecT0?1wIF^C;#{8AzkwH=`8wlIRy(utf!kP zbpg_#?={>#Qe4|Ds~v-9WuvX0nz4Kko%JIO{%b?DcU*6w1q{4{41ZxkU!b-heuy*n|VbZm)NTF{A*79vK5&ryyZX6TBotOFJ7J}N z#fCL3=(4=4CURl+E9FqD$6J0@*CIL0E#KVo@zyN#LyHGj7>4fCZu#^q5vGZ%()3D< zJL-h#Yb-qqI?CRv(9CxicQ2gzmdXCET)v5!TFku}>frTn=(-74mu)~RF%!7BDte9t z?+T&$5gOBHps_k!I6vXD*wFoSq0hI9H4jZa{vg}ro_*Mb8w>R94L5q?>qq}X-?UY! z%K7z$MN1@vLVvi6V#IyR^7kGb{emuSVhY&K#{1lOJb# zDv!RffWFJ6Qmx+6JBN1an4h8{?#j>R=lrbplMy17pF3PsR6mK_y`1`im+esfOy`~x z)=xbS)7DSC*RlKk16w=oE!Z;VbVi3uDhm|f0xj`Cew^vWGPFG5Rl|In_IJ?c(~{z()6P9XK7|u{4jZL6qL_L+`XK9Zsy{md@kee_2;v|$i(D)Puew)>AGX|)`7jssw_}un0%sd=%Vid zu=%X_sn!)_n%Ij}pCnw^F>&==e&oUxNSIVTYuHqndfvv}%gO&(E-uP{Kki80(wuee^dCEcsO=A@xIPUh}~dCa$19X{t_ALlblVH z^4*}e*3EkF>4kStCA>^!S>JYK^o4ZGI_iUkS*Lxxn%WzwtRv>@X1!Uf62(l9$b<{13vL1*li~LequSMg!S)m9Th>vhDa<;3k84Z&rLta|#&xq^^4T7>*S;j@_``91_xI1*6c?r} z>!+;ud*E3|+Je-=biZGa>-R^}-QQ>~0Cj)8x%=;Qzn-7Fk62NBgp0#b=h;toobNxe zY+_uCA^T9jZ_kA@TcoHzN8dd|-yRx9cWQ{)9!qUIj(YIjefiBRqvrIk;L*=xlQ*uI zQ4~OZFRlRM*Hs%gJG;OIO|}+0)ZT4yk+#dD+80O{1yB!&D}aV@K|^|UzUH{!W!spS zvj*>vt!fcb%q?9MK>ZM|0NPi!7&_rztv4~QTYg*!+OqL+!0x0UuhT^V)EnRmpyB$w z|2B?3v3Wz2ZEiCvHmmv5YHd*KI_aVSYS3Z@*x$~H&b`jD>+C*mk*=G%Uu%)~jO(gW zpVLJFG#14bK&HKU(Mn|o+#ldFuhP0IXX7T{-COX5Z@MUeCZ)Ins1f@2wYodhW0KR_ zA&)FQB2V5M{q4fnbWs2$E>@rh^Xm_*+t*p`b+)>9Y$N~U)PV!}PxYVqD_s;oV=G(% z#DY9$U4Ok^;pH6syt8xXwM$>@TQz(ju7I$IEJF8?IqB!nCB$uMJdyh<%V@giRCB#3 z>N$sT_umCQ=h{{=eTxUY@(6x?sexf z@grIb{HzNbWPuL#pf4P=b3gR^66jMX=v!#$_jTA0L5!vm_R}anU8=5QXR=jwq5mSZ8ylbg3+GUHKzM_C6X^>yDn&8jTC=7r z??g}{KmC*zmNp8>(J_%uHJR%nS9<92KFsw*FtbKz8W$3U{%fbNX*?hZMr{I>DHIX% zV;9sS-GG>p!w)VTMMeMHG1p@*7vh3L^g&;LYDE8MfA@<9=qA~ccF+YfSRY+Hbl5+v zhi#MGJs(crG+&a1IWUrq))_Sd)GMMa+$fQl7d_vWzDJi>Hm#RJ*|d0GXC(jE`F5pH zdRs~#tIRY>TAl++gual2ihm1zV?pEap$Cg5Bl`Ckbm`UIRj4Gi9~SbWU#Dj~7aW_% zNu-0d7ZRpr3hkK>aY+l3N>EA;E?1u)$wWW2(U+NI_n^B1Hfx-8>%7S3*wqhtQ=C|XG_mnhqO*0nrj8RI>9{#6u@kAU5yFu3?QsQ%Cey`w0F zDs(`|;3~&a1ibG?eQ`hTDbyEt@Ps96Z&Dd>9zvUG2u7IZ@(rLq(ghS$09fu4- z_qkab&qQ6XWS&To$^0 zZX5bwG#c#=qJyX3+E^c{uG{Cr2nk$E?t@SCmlv7KQq<=n?lQ?CMlu)ATlR)&=xhkn zKS+&txnOAr^>5M_q*Q`p!cm_K-=@MJNRD6*h2pRxKO{##gmn5l`dmv2@+dvtWkbvG zAN7LR$Q6!vtI=Ptgf0Yfg2qxwS^*8?&Ed?4y{2Yz|C2}O_^@77171^PmL zZzb+t&Up7dq((Qk2NHd+?jHNC7h4~PPWa@#`O0CxVsaXZh5IWF{+hW&L0_G6P< zKNP*dXvI(OVRi{UEx3TgTW8`G2Gn{@-Q$*`n4IVvlKyH*eb}BYO4gKdN`HQQ0o_qVmx(+t3@ruJqDC zYx+!)H|^R>tm4r#NZBzZS0t=;9+z4y)Lp5NpRD|ta&<9Pyx&5&^74s$NKRf3LIQMpTe*AC8&$OfhM~L^4~lwmGu6*?TGOppce{sWMDfvn zjT=2#8O1Evqk-q4v8`qZC3(^qx)_X>jP^3n#m8a2Y5dhNlNz7HlOh84eOc1^WQ>FI($3uLZMdjVBKCq#~E!2C8OQZ&k z)DCKTQ7CC1C!OhQ4K9%+rbIS4eIJXolUJ(SxTzthfQpro+N;_0h(cbo^_6NUmjP6& zlel|1rRoY9r*#xATQeFUj8g@op?2oeY_8X;LALHI7Dwfu{PX8QG%XO9YE2qx9y{eU zJcUZ&3MUE0mR};=L%hQ-X!bjCX`Xx;c&V~79G?ssB3}mEzIiq1V~*&4TyeK)?}xps zsjp^yxk5lS(~`TFQ!|C3@aVG3%H0Em^oBtpV5nwBPAJ^iW%d-;ZB-7a?`JDg(~`!r z)Bm+S0329VsZM9!{|uf*@>bIE(Di$*{sL1j$21$lkW4pLWEy=5UbYt;86B8sAxx8C zliAuSEfzp)Mr94HSx#C1;`Bs1zrl5;G1N<-3(5gYd;iC zbI^ZuKm{GzR;k|9za9opAj!t*SHvZZ_bY|%o!fpd`4#I&Xk|nfE8|&`+uF2B^iTFH zk@r%vyg7ErBeJr!@A_OM=kDdS^%78cw2ryCdw`JMQf>X& z$gA1je0fSa`NQ(=DxMD&j-j%zTQ{rWycxj#UbN2vAwG`C5 zv^tij%b@xx)V3`>!V2^WXn@9?=zkm4aC(;&ZTX>}y;iAiPH4PNC`(zn(*h(fVGj)D zej%aocL#s@<&F!MmKlERc^!S_E}TD4)7`ptw zEromW_^0s`>lX_Nq)0eP4vr&=@z?8`6IMNHMyZEVxpRLQK>6-o=dg6lFwQ@YLc^+i zw)Zxt3O?&Wp+TM~}TQCgm# z3v?|`EYFayg#)%`&Fm5MvUkj@)*Daq<%w>X{&Usb*H`~Yd6LR)k9ydx_X`4a$`f$B z+&~Tq|K0MufAYjoVtK9#?tJ=8o($B+(^ckY9R1Knw>;0}yk7E;lqZxAp5OMrK4qUV zcY;oN0*;p($RXjle5LJk#L2c9iRD@S_VmN&10Q?uZ9m96w#qN&%{ zNO?l};Q0kRPQvkW134rdm!q^iTa2)&Pb|+t4gPI7wugO_ppDM4Q!DSkq}x6>mJjbL zRi1T>J^qAth1(0@FA2xX2jt*(3h))!I02RCumvNd+wLAseNlDpxV`OI>e1G>7CYaK zqXrefwl~lGiPYxDySHU6q-MsS%cF)rz{|5JDmVJF?;baIPrfse&D7^6wfpDFkW~zN zKkoQDsUjT9tP;|beP%eymM0p*m*nv8^bkEiBZ2-kw2_@M)o63E`9_CKH8zjg@;INZ z^%yjSU(Z#8H5ZTI@UwcgbOb&e59Z?QgyT5wXXGH=tkB(WO-!KTNDY95|H+1dRsgI&8P!k9;eE6K^$_6sJ>N3uCRpB)UPxG>C3+7 zH#;B8eEFM3ReFE-XYWDG+}0YkK(xZ9YBMA#=l==^kvtogE~da0%=tQDV)dEQgV#LL9m1Pf)8+$gyWn7IV2pHqm+Xck5*bG;vkeYLxB#I zZ7#bB>BB)tNaXTWqhdRO4wNXE_Xy(gnAD9P4pz4d4K@`A(QY)l?DvQKbn|YK-F?Qb zw@FbwGDIOTvnth>{R!?|7R+=B^_7fWj2l=rK#G&57@HzZC9bq8h7``@YE~%kXS~MY zBuw7kB|UJRX*-l+Q=)%zmRqDC;iSnP3CHCq5wMA9q;&m^o~wFJfvv; z+qOu5tzGPVsm*>V4o)!JML8Q+z(L$@0S8GqZvQ|I3CHCqk5X{oEP8GKp z%t59zXJ{e8nKU>E3NVlB{E?8S69)l$I9PUD*J7sPAip(OW5ejeIU5Ff#ul8gd269- z+N~Gf7B*k~GP4v9&9+e11~QC8@wpw$5lJ|{PzQ2II4(yi4=;Dy&`^Sh8fewg1Cq}h z%tINrkWYwBP(HsvLH({C9y-@*Ud2>A9G9b%gJ(NtdMv>~YQg2; zb-VJoQC(+@J7q8jf5#Sr0@56l&sE}DscnH%w@k%Beva7KzF)0vc{)+Ee=fQ9AlO!A;ZvrPtI4(yiC*7z0oFc_Z&AW2N177x^LVFgz zZxT*|0_n!d*jzSwOvOpwE+$mB>1WYua+9qO&K#-|wUznuv(_%o&)EOE6bD0$IY&I{ z6InEQc?sstDc!<`k2_z4L;2iE@r&_nTw>>_CWPZS?=LPm-))?AnqHw@C$DP~L@nyQ zcl)pG+I1Sh+hd0wYo4=-Oi7qbk#Le699PQ00@Zew5OQ$NpabU{<(NWUTUs&G)1rQw zgY|~yGnj+uB?(lVDivR435=Ki6UrsT`uVEns#c}aa0)pSvh=NQFYnTP#;Ms92)5!vqA1>>^?t z`j6_B8D=ah+P;{Xmj)j?{=yw1#(4&KLF~}+*&i0WJ2(eXB%CA%$CdK3>Y_%&g{`LC zvK24Z%%$~+aPZ5Me}G0cq{SkGd5Mm^lXzKyONfp_U%I@s1O?a#*k2>?vc>pu8%@s3 z%7yLDZK=_{*&3%=ecny{c@1S#KQFJ`Z*oM6muh3$%VYZOWdc{JxV_~3X;n@N-#LqG zmB-aAp5l19WX-?{H>@e-H;%pR$=XZJrQt{NMh2EkxBIIfhJ zS*&{06Y?^IHDem*WuG>^tul^!u>aXYgL#>gD^4kUIah2ib*j1^rvNH6-7BrChbQ!` z2Ey4J%wF<1B#m6B-p2!wD=cATFPVclG;Y7#f7ycLRg=AD470p3c}BM? zD6%zTm?iz6w~@~uF0?jt(O?_N9Vpe|7T^uAwVpGqjnt5EoTDHI$CYxib@m*Wg)OBl zYq~U#icGvUrSe27bC+v%4d$Z0v1>)Kjnv`dElvT{I(082aB+9p(}zsXMdvdU26R7_ z;69_3YpcsGmU^R{>T)rv{*6{rTr{t*%38~T!`*kk5BDjPu@?o+3D#yvcw>vxzdq;F zuE&BL5{}DJ%Ehksi?0j02wQwZGAFkR-QR)QkYnHpgSm*ttL!Dg9qy11#K7Z$0^)G+ zNyvjBk*miphBWqMKCasp9{7W2QTg@NTaH6V+?j6e8uczix%Q5Gb|PIw<5jfh$lJ&8 z9ldr)adM0?$Er{q(r#J>Z)iCGoSIFS_cLDOj8#J$-d`4XF_^;l1rPo#K5clLSwtK^ z9}aTxeMi85=fwe3--$I3-Vk!K&zDv{Q}a%s*pgAH_TSoD+F(v{O@)>vE@C7cPl!!W zHy(@Qf91y`?s;s9SUO9NeT1>8Tvw3n!eE|Pr_O-T>8_ukFbcfHH6Y0!5(!WmBH zvQV{JTePZ~fd-FIfob^3nKuVJ4=#Uo21UY^G8UJk)G8KVJVx{bR>#MksgjZ}fMTs< zGs>#Pf&vCJ5Gli6x{Toyf+&nDh$neM2Op_jr3|#m-KmtM4djN6 z@y`mT&pFgIZJ^}16=-Gz2JX1DWSyxPSdPnw{e`EStJZ&>%WLC@gT zMH|8!cXPT)G0;37mBm0XVE8#vFnA;!KW_?hNH{J>DFe^M9QjAcK(J46477+QFpI$q z{2fCG3h<;8-57y^70#v{F%<*(@o3MW+sUJLSTqZ}vZCSeu8)~L3*kDcs$Y(&OUyL< z?eQpnG!$q^!twDX(2#`Va+K20%fG=mDH_7b&ogC-o_c#jcixZ_H>LMEqS zJ=M9SQ5&*(E?L^9z0+jB?1u**OiSVK%xk zl4#h4ONd0nbU$qRhU%RG3IgSivHuXg`to!C;GgH%0=a3Uu zr<`>pT0^cw;?IzBesFkP%_8Y>wltizhMGeo#AizZ-;SLv-N9Nz4GAa7!EvQD+?ug$ zbs-HoBc<`+j&}Y#qE8`%X^1|5PNHEC&g^nkpi|Z9eztTqm3-X*8uDjIF>A=ze!GX>Ng?*10OhYs%WiN3N zBMcJaB5;m29w;CV2cI?`Akwa$vonV~)Ey&-hH_7>K|G-%q|HB9OdIc&Up7G`!I>w29Cf!iEKV zgsm^-Q(-{7!8H7x4GT~}*s8VnMxf!vSCey^oQ9sM?W;Hcx!Yxq$N32>4}N71r-=ro z*EXC=mZG82KbNi=>mT?yF^rlwOgxLq8h$r6DtIxa$!-(-q;eSw>Y!-w*X6FW7E={x z?OK{pK>G%~_2BtE=bQ_pW}Gi^@tfeyc#?e7VBtEoh&p>Fc`#LUcZ)H7lO|G*s=8a( z^_tH4=TNA4{%L${l(4~~_s96prLSpx^6ZNpEj-uz1^Zmfu#Ej?be*z^W2B03iuov@ zoTGqs+yAq=ZO#bF8XLb~*i%2Es@EbSUIv?XgB%i$%U9ZyHL$GPPS`NAJ5aA8*3YA+ za-RS?eDkTb!95vzU5veSdmcy#V&L&W0dY9^bmc*a*wr(j==pxsV^j5H%qyC-ruO~| zQz9~bE#<2Id1{=^x5mqn_RN5S`$8;w$%h%1HMsQC(M(5!2No+n{@faHCW1Oyq2|F6 zrF&7RoY7T>qbUi`i_sV4kZ@d%QaXOTa41Gd$Kh8?eu?ihpQ4yA#CD+aU0%Q3U^=2{ zHhbyP2NHr9csx)*91cERc@QFY_0Tcr^n#;JPRI7`+@Gm~&Us9&@7t|^y*w+B_L6iQ zWcj9(6dnKQ3!LJ`W}THxM{(KnJ~ex%Q)f8N`;EU9JFxMl0wqsJP*+P+#h3ompJFvq zsQ?ehXnHw0q$C9s1)$)>u1?j8gL$7GI(C~Lvs?}xu|;O1Y{l{~aCV4pyyD%6 z0p3xAFP>>ST5|;{E}U*NA5rH`q|2ebx1=~}{(!Tr!-6oz?v+ovi5(bh^oQYIlyLi-KPX5k_6%^p_be=aaHQK7ykWWb1ZiTxCoC2a? z-eUwF=GvZpyUBU@?dttbqat%OpR(gs-!ZLD#h?s|?cvKERqW07(BLT}*sMBlJIP0#A8~JL&9-6N_n`wlAGuU@4z0eT6fB|&)dG#!J(0}4d$V~DI+ArQ;WIL z@(UCYhl5WW4-jcr<6CjN22F^RRfO-a8BT{n%`-)$^C02dni!xe)WP@{l2tbHyO@ zN~)Zd)Ro-Q4QV_{!g2csa!5EXM=1~M_vk5liDd-0bOQ^ScLq(cHJFEJuE<`xyn%!u z1|AO-5Ql?LS003jT|GQ3+M>G2KHO}_X=#7@VX<2?w^eXm`DSIt)Z#a5Bb*t{i^=%v z%A0~xM$t@0S%XtBe)uE~2Ad=tCl|;e;kX>7WVEuW{82bKb+$jCd3<3m1#`4lJKGL1 zn2gMVJk#!U$pZ;-&60Dp@jwA_IQX>j0Fid}kg>&u1B*;$6nQeP4zj%B5Im{5`bX0E z)hDhTMY)h51#m{ASo13fM*j!_5 zhdQr4i1+@}sto>xGOUJpT+Ifg$BSmG*!3HYD!2G3B;b>`#Z_AR){_F&vav@eH6)xQ z2gjB2@KUmS2O$r4`)zIKvTd=ZOh6N>*0sh_lj6G8H<*XH>D+Nu25-tIK!*3Q32_CG zqEpp5IRzlT*iEbIA+{bKj;I@OTMiGgy?*|MG7=6+BbW4|8PCJ^v0oDk`HgYf_OW>A z{nn?Cqld&ibclPoNXj0Xmu?i%wQh=jy(hgP|MW4jKITh(f)Vk@KEl)KEx9$OWNP(mu@oEn3l4Bv5QlX z-J{3T8d`oq4@)fFP!IhxNRiR}Z9G|I{4lEM!ld`hb&i3DT&+7}XH7DW&;39S3IE-t zoA~Ba%Lt9)@wSa`7YmKxkB49Dy>qz1WX#DoOkMIoLVOhFMjJ2Pmu|Auu5#8?WGu<$ z+Wt%M%Q;jfXZP7#2iZ5y)_xGexuqMGf5yczW(FF(z27zekEoy9qjXM$1EcVh+<@aJ zzd;TO$K@zBhpNWYO9~li_rc~F<+YeU5k7AA+f@cLP~Wy9B*e8v&e1Y3-A{zqcCxWB zIRonrt374w3bpI>%pAAHi0qhpwPVI7tqUD`jA*yXB4u8QAb_r_IB{S5WJ?GuY*$otqoX zz&vz=B25e%a|yB3Gr=M7_WdWdki$T10%(*&;QTw+$6rpjPCk&-d~d$$kJ{|~c8O;o zGb*J&66<%%a;X#zN14yp$T?pF1`Ho6g25x<_>dFikZ@d%QW~yn_{K*_!z!F1gppvm zwOx1o77c-BtgHPC326~@r!|D2fH)j{+IWCSyL#4VmX9cMLk)RQjDyn7~mPsoA^behxXsSRA-3>aNN#;91@Pp zSIWQ0k>&FU`S+>7_@fu|EaI19mL|_`V6gqu$3IAj#J_a6f4@|}I-81r{8Eg=&m2#l zmv7*{Wt`*CpCR*}pwfV)nC~rLnioS=zik0Y%pu|U0U5A>BpjEclz|Nb3Y-=)kT*=+ zxs_6NPh>Ngf!TO^>5drrg!nk{XIX$zBpe@8f*cZ#%TdZeC%cq~LI%Pv0UTAiJaCWU z-`)D1?Fdi+wMpGez*OBp0itIPxFB_4FHxQr2V#KDz@{O^Q>Ie%@GTBFsje+ zkL{c8)JtO(ROieDx1{zLe21A^HqpGmj>iCg06QLYbZ2r*so^U$B%CA%$CXmA=Xd|6 zLh6l}vf1U-q7@oD?sUqyGxNq6Z2a=lEs3-W$|XdxJTbxXnCrh@$vUQnt%4fmcnnXy zkG0xSj=92}!`j|!-NQH6L#8yoFAZFu?$o<5snVn>5B6|WVrxPBSGPWlOg%2C^f;Nu zSu4$wQR0vH0bcR6pK9h&?a4HtBncy^qADynZ=6aN-6ZZ*pzkjxL zFqnGi+qop_aS2gu9q3kdeNF+cjxfgvR&RDtR#|V_rz`auB=zl|dG#yjgpTdrhsCY4 zXR_&Zt=oZgryf?Im^ZERH8h-mPR%CB`x!54E5HA}Wzs+q2Auc+5^#JG1>}%$T#i!e zb(*&4sE~Rv;Dj~Du>RB58%#ZYyYG+?TLth}TNR)Hgos^jJTZ>@^b9zU{G&Q$@&Tt) zL|E*|5?!gdo~N$W2(0vp(f>sBmMv!L8NAv8l)=9{0Td(Q_}mTTkZ@d%QtCPM{ZLto zdhl6^mgxR+^Nr;b*+2)eHo^K7BrhX^-01v?_NCr%ZHJCe2_!JaXCt<_psh=8!77f zez^Q&!R%3*fs-7Q45l7B@xorZR7uO~fdU{w?CQ!Bhl5X#)f?UEo5|h~EXnC--+V*U zS}y&{x=t;zvsp~XIdu^Z3!P2<)-;x4p!u+iECvG8u8%6zd*$bW8m`DyrMb;^5{@$p zCw7+NpV{9*-pZ7O9ygDI4(yi|Bhu0tR>_h?16&;DtA1~f^^{@B!u$?{Gb5%#jX+f*FA1~ zZ&UG)w}AInH+WIH;qazYTTFdDee$}uD3@RXYxXNx&CEc9r+;9%NX#MOo;7U_g}fW1 zfd&V1NH{J>DFZvMxp_~>K;AHo=xkShroYDL}FADj;uH`C^BzGw z9+SG!V*!umw(M?l1|A=keRPo>eLR9JMm`%-ec>~d2Vh{}!N{Zlu0OHFav*Q76=MJ z!HHcXFwnPb&k$2Fkl*n;Qs7j@p0`Ij1+}}i|Lw__woERcFWvRT)YSWnH`}|hFa2pc zwZGD((krbo1AJeSm))Yb+J%;5+-5roC&|HarPP~~ec@N3@f*o)w%==g|3^~?7iw#G z`v8Nfhkmt?wByGmL@|v`rMu&IuNA8R8;<`q0`*=r(^Z5w+I_* zSM}k-LmQcVX6U=;g%tJ7D=)IFUKj3tTYP2)R*Zz><4BN0!f`oDsrS`$Pj4ahs&cOx z!Ne@9C}axJ^o=;mcUkxO68cw+qQ=|1t7lI)u~!>Fz?gDzY4*<-pSz~X8Mf#w(Y8W zImS4Bw08})+Uqj;PLr95-uV21z(B zM=1^Oh8%k%G=r5nGYISdr=QyOHrNcJ;e zAe-1V0`+cYtmG?)de|7$xbHgL3O#h$er^1J|Gc6r9*K0`+`u_#Kl&J-Opeh$mDu&2eXwjwA1u%l_SC&#A_*x4$YDj~<3` z=hXZE-H~FTc>z=w1A%F!9y|6AIx$59^#b3GAmKQpKn@AV4$3&Fhia z0paWdXtOe}0|T^c!Oqv| z!aqoe#4Auh91cDs@NZOus#{EM0h=wobZ_j6lCHszmVP)lc0whTKd^vjwp1-?W}v}G z&%kn#m_x!BteUm0yVFb!G&PVz!f`oD8F)V5u+l;Xf(3jg@&1ye`8OZkK zC@Z>*frKEVtgDR&3W&qOr;P`Qw5wuC0y=k!#jAaA{ z7P~%ksuTmwYoD@gAk5xcuba@S4!xNM4FniP!tpUB$RXjl9Hk8Gl6hTMAp>C+IALmX zRHF4%&8p%h(&wYskPs9M>uQ+=3W&qOr;P`Qw5x}Kon!y2W-12qYoFh;hM(_qHpO*i z{Tl<5ohMdia>7c3$6iFO zlS939UHjZsWR&0HY%|=0&sVI_cU$+VOfG*7%+*kedghfESym6eOpVXXz>1M@d>jdK zNH{J>DfI?b&-YA7J^1i6OuVwa@H2eesc+965+YFw6cC4l&j{4JQPicU9O}WErd$_P zL@sIVlNn#q;r4^`WS=)L|838W9am3}9n-}QJ;aXIXVrd_ONxKyqi3@C2S?0$VxvyL zYhWv)aP*9XljPvIQvNkQwEeA+e{l5d;FDSj+pOnmCdIki7;O3w|47?@Y5mZ{7ES@w zB6Tk#@b70|?^Sa6hnYU(9z8o`-^*oaE`P6u^Rtb!x#F=6<&>HCF(jmqp4sP)J0wLz z^8%|gi(xbIC?Oq=(r`Hs7yEkNfi zC;Lb-(7gO2i-9oU#2Et1FC-ji8pt8xxE!Sn^xrzJhLC}Wy@~(@99ZT-?#K7Kfv!ouyyDuk>KXGJ~myUOys@ zLDTxy=MYW-Ae-1V0`)RY9W+Z0^{_FhagUzu%(v{}zT2BTcbyn#JH0`f0!%JvoEqQS z)YNknmpAT9tNcmfJg#OX@_xpP+KTbM^*Ook{(7%Zt2Jy&Div5g5{_>ofYl@6xE!U_ zTfKCIb}2ezYS?7WysnNf4W^#Hac5dq4-|lc6T9Ln6Nd?Xdd8g|cej<2Lp>Nz z%5{awlg6FA)${LtaO|vKIh%yW?On2Az?53d!{@$5BuG*3kFLB3v!Q#RR{4{{d0frP z#mAFC*Qpg8)U87uECBjflAC&(e;xO}D5JKrMgzR>EG*_Uro#jxcR zEIhha_|-aHs0Rs&t5sVSpny0WeA;+`NV|Hd7uV`bn5n48|HNj!$(1s6ul2$;MjiI8 zW#Lfvw~bP}a?79e%1g-hN|HaXVy2<2c^}XXpO+o-TvXJ%(JG3BfTC+BGC3rjM3hpny0WeA;+`NV|Gyn6c-isV1jk zyKxs+mUJE5WM;_dUv96;WJbBjETmz<8iie?tf6`NMHUT#Za95%OXIHGGju%}y5@LPBEtXz7*i*3jeDvp7@HkROQl zIyJvc=XTlLw#9#2Qr30wcBV8M4)b=9qMq3T%Ay`vE)r!(IDW(vVX2{aPVm<3W&6;#{!=B&rr`))Z+)D*>5fM&9T0x z>(V5P@1rlSe~oe>vVem!c77&BL$d{xMMId!;Y%n$D-wdYbD8mjWnnU?-PyRt8={P%V>8^jXI?JwSdxD(fJbEdA*ngZDQPrzNU^PdZ5 zcdD^CE?PsvNpf&pDfRBV9(gXLUjP3zfddnxHDkErm**dhF#N~H^ld=&V-up-s@Hw@ zJ>AcL9`4;;*3Z1B>juP`(mVI`FO}fBW^s=LuLcEXV@hLp?SqoP@NPc;Da-05v((d> z-+>jw=WBrDgGrD>!f`oDsaGZPX^N0~Ass%h@@^Bw&-?1mE2K8q>M{E`Ol#7$Qjic! zJ@~7Qm+tev4F__(HC&|HarTlBObLA!>|IS7fs+n*unmWWCzjQkKeC==X538~St}0ZCTtcj$|H>qD z^a^3=e*Uvb)6FI1@DDS6Mmhg!!_bOdv8Nylq)paUZHBhCR z%*AA!VQQ7FdGSS&{UgoRNH}iK!2XeNT#i!yRUP)IrI3HYoc)8<|7>?E3^AC0`aU=h z2?^WRA3b)~$aeo(IsB8m@ec8X86s`K^NTN^TF%e%C@|P{M(&C!HwJc|j~*5+z6`%I z=7tmv&5JLxXb8hfoF=gNLc(#nfgBQ!%TY?h#I+GkgfxUT5uoA1JT2d*3k@M5VXOV4 zG>pI5#bm#{!Y{rYdy{#5#>}}qr(7>oY5el!r%Y)y_*B1;6!na10n-?P{>6(gmDqDI znn3LIC*WJL)1R;?L&8aNa9k<%Htc*hQb@hsr7wI<8WOE(&K!PL|DyAQkA zgeaDJx{ELAe)`ir^0cgTFxUvxD5pPp3s|?(=}xx-FSVGx;+AdY>p32w(hyldn;(N( zNYT)20To$5{G=vWKoX8`Cx8Vc;kX>7G%PxAMF$}b!7#x=%&I=_B@CvazJVwt#L^J{ zYUl2t0ECELZ9FlK`}Ax-*ghRS&r}0Z-U7~FJ8$Cmq1C-sy*&Q)dhnAmjQ(4T?73@d z>ixwQ@C*0;!`Q@4=fZsEYM@O3zJBhr-R}41@VGDcxe5|al7r()sh9mq<0?Yx<>uah zC=vQ!_hR9bHBOolRSl+|zEAI__5OoBrvMb3*fj$68kHG8Ob+$Z!vgZu8?v^Is@sr( zRQ%H_9$)(AW!`~T1`4?NgubkBzb!=Sl{#WxgP$7WlEVpD*n7tP7!C5^LPLhM;N~xF6v%(=E_4065 zFVwx!`mgj?uWO8ZY50%b>YMkaW%ZVG3P8b$T_aF$_RSe1Ye`7=dB#-$+dP6PpD{`R!`NSWckL) zVJ-GFc6;6X>9+CA!_>rs|4LEM{Gk_F%PjDL7MvPDB@&KP4CIh-T#i!eb@n@(Nk~2T z{tC4GSs5m8OBd=vLc*3R+-Lv=#NpsG0`*Efur}F#Ur8<>_GQmrEO0LK5YNrC*0;_R zV0j1O@SWY7=ck+gg+K1N#9w&gr8M_rn#Fqd1%Uu}uu|q;Y2ELF)q}R-n$D4_KMiIeI&nri@sidT&$4q0aBUTHjKIJVRezcOi)TC9UB8sH z#jE*ti(H?n8#Dex*%W>8EM`m-$)EZ&>cKOta4~OMWo>9U|D2jlkoPlQX+f z+^_+jADb3}91@PpQA)$%U3Qlg(h$DKdFW%`A`RNi*L0tBx6*IXP^yR#1_`m@@K;+E zpa6u3U2Qxuj{Eeiyri6N9crpEs12v5{p9{f&cp>?@?6*_vc^KqfGC8s2hU=js=TEJ zqUQZRSp!kv6TV^zb3hV~4=h0r3CHCquiPmgE`=X!Ob&1*f>}7rcV2w2J=tf z>qd}}m@!&jfdb-i@M+@#BJJwoUl;qu0jA;~zw-GlZ_{UOZ!L9Rka@|Xq951$Gr4FK z6?RUFdgeKxEb0NpaFYeUUPQttU@N5{hlJyDlu~ckN>ubG0^RdU= z<_1$w-wU^pkeD)BN`V66aPVp40V3_{p2|8s`7=g!x0n*4U0OXRNG zGf^&J4tU-9u#cI61}}gD)9}F|{N5M|#~B53NH{J>DFeOoPZ%aNe(*D3F!pYe8I99szK4;IkUYn-G7{F4hX{}0Z;>}~0B z?rMCP2AT$(fAQYl|IoId3wa#QzmRZ}92{55z#mn2y%1VJIRBEr#~r&G+d?#@eY}<% z%s|wjNc#|Joqs9KDF6j0c8y>GUxqHdCWnFPdj4gCT?yNXliqp--I)|Pa@f$NOfDm~ zT>dC!{Qe~M9L430`_d|ZQaF#RS&6)#@fv6E0gTpLtC_oJH`Y=N29qSb14c=ZL&9-6 zN~t%gWU}OMJy-_S?b@Mqm}YqFt4{_~4}I^2y~IU~FtD;*1kTaM0|mt4;M2wfMB3G3 z{5m=ezb=P*aIQtJD^w)S^Djr{sO%zVgt`VNjvW+U`5Zf1$ZKtN($v)Zi>=;w?$qbo zDk&+>-xg`0LI9sJH}_+k23ouqcj}XbljPvIQtDNHa4ty7>K)FVzy8edd74+X?XDV3 zy@GVE4YhiwIR&8L#I6yjcV?fftsLs5tJV8l{F1}@X~FKZ$8NWrzGeC;CYKEh90`%4 zo_WeAYsv>Zha#+1G}ZTH4zuG9QWjchzE ziCJ=iDW7McTeuVhjryv)bg==-e}U&OJbG4=J9^d~8%F|u0%PVZ?&ui_C&|Har3^fA zJjPCF{NU)>oQp1F2ltHB)SVGH+F%Cid(khgqi54N1)wpAT_Z5?Qu4?>1{go1d~At- z)jhLLYuG(G@VM_H%@C)G#ea*2EPZro0|}An1qz76!KW(^Ld32f zL-?~%#A-P-lsoN%ctQn8(?1(7l6_FCYEzyZb90M!IJwy_M|>%SvwIKc=cqeM@$XMA zzx>5>K$z3T`Y-SB>Wl7NuXR$K$BBAc{LIeem{P-6Xh=9o4vs73U!{yLZ-o5wpR(EI z)S?xd&<=-IR;6D*s+Bi*oWcATpg0HXQ$J1pbvfe}AYP z{-x_2uvf3V=i6=i&v{<_{tCr*hT1autXXUFDpOO>5ifDEKdtg7h4Z+YmB;%TuW?sC z@fAy0`6S`^oDNJS3CHCqrJnU7hpa;C!Gh!<+oJs@JP6Y)+Pn6(!PL|Dxm`$zRHdMR zI2?T9Dg#v4)nocHbUNKp4)wsK$#sQFkW3$c>T`$%1ctDz3N(5*4^@S(C5 zs!LJNy!;|-)Cm;BM~iUcg@k{`R!Tt*3CHCqrCz0CFJB9(2M1Bs{5m-MrA>rp>0W=s zzjUo{#~l(9wp8Jpf1rRk9DGKg-ptOe-AqNjl3YIQ4;3xE=x5J`UQ1K2<;mVKsv5#! z`K6Nk#0h2w{`RR)d|n2pK1n#vsI(Z1%Tda}l%F;t2Et)Xn08&R|0~R3j2+8>I41B#plfPNn8cu6-uk+4W zW_(@rFfj1&)zCLm3^cF2D6)b0un`zV!f{4{4J6^X9Hk8Gd$8vvDH{ko0L~Y$8vbLO z`WTp&4Fm;*4O)9|1P0zNHsGkKY@iL76Z@92jfdG!Zq{PTwyL?}HfH^ZaCYS-|9@+G zNb%1+29?D>n6{C4L&9+j2y#d`E=MW#=(?3u^%Q@kl z5%{-jO9Ru7K`&(Ocr*4%R?kIiG7oC7A!G{5BUr#=bNqKmG4M~WeL4yYUH3k%Y9NL4 zxSEy8`x&os7GOx04#uFkk1g^aPAd4!W6o8_c{BSr zvt+b)J?)erMLqMlQ_;9{`mdFXUFSw>phdtuj)cEiK6%YR@1=Zv7sb+KLCKC;&p1!qDNC*msb+wcN1;pXt)5Zft+SNn7%bhbfHx>2x zm6uJu2VWiJaLQ%P=YU#u`t%!zaslJcD}^`4OEJ*A@*<0Yz_b$G6GBQ}SfYUj0^>*$ zjx!46kZ@d%QU=~ypJ%j?fv_M_D{*Me*SjJ${`)t^8O%U^Z@fc7P%x~kWfmwP4hNq$ z9w5@L9tI}*p6OyL2HJ4i+BX{4sMzbo;~w*S9Iy`Eb1f9%?8-}??CM!k{4-lXS^NW@ z;k<$Q9SO%R9mpZ!xE!VYo9R`puaJK*9RmY&|6o9!bm1Q)B<78lSD=769DLe%fJnP~ z_~)NBzscTr=Ph8*bzWOOR{KOP^tHS6zKoX-$^}@!172mV%?vbn`UjSa#2gadzLDRy zdAXKpph1Bg5{}DJ%D^nSsO>@qf?=}ERnwzR&1IT6oB|*H?69N*m{Pa_j=6VDTjLLdgQvt*yoey?{aUk+x_I8WfrB|FnV{k ztU6JOdghfESym6;62fO@V8uu{K8^%ABpjEclzO`|e02~~4_*R-iC5R-TMrscJ$-xb zkPwiBb+wcN1;pXt)5Zft+SNn7n-wSJl0!W>O(xeBDndGSX2V6Yf7v?j(xZ2oJrged z+c5C>>PUpMD=(S*+^!(SKl4ksviJut*B-=1oq(6aRz%^YTM|x^gX2p1x2^T~5F!6+ zbHDfS>hAtJ`$wcvtyZwGAkT%)E~wA^pm z{6RdSA|x|dl8abFOHpk$4N2pPtE}yg}KqaPpcY8 z;XJNpW%7Q;Yn(YC3^;Ly!14DFeU9jrt*EAS}NC0o;o$y_+r!goMP^ zs;vr8KpYM}Z9G7vT|EqZ6xDf*sTjyFzZBlO)lZ#&pzHG41={^6?l+6cMb{H^wn|aY zJO@-{{9>_X7N8OdFNH1Ffbk>YxE!U_^9gt{UPwKdnq6pjZ~L9<%QUg^w}K3&p1w~n zK|*56Xek8>h{M6BjR%OdtA~1fl5S=(74>X5ZS5cXFNz5*a%Z>c8ifY}=JN5M(?fJ9O|IAo< zZy6cK`2=!EI4)l){|?{K%oXyl%)We!Duykm`tJF)cK?W_nvk+Dh8WC0eeWGXLQt7_ zRe%EGaPWz%3{YKH5B~-`)cI^G{_!7PsynsV{)7@`y%#*|{O$FvCsR=lGN*RsNJ!5C zk6BE6WTv6PyAVLP7wZT8cQSE_23p7=&qYPO8?B;9I8G~&L&9-6N@>{bYw7bs8pao{ z5o~#N8I@YFcx2elNR9g1pdAL&P~RL75`uzZT`j#p0dY9^wDACucJ7%7rx?98CGyBal6%F}`;NiOO zzRjAj!7Jid?>A0%7B866s9e8ORw?S42coj52bPOO84`|9_&^Q`$K@!c-r=@;G7G5( zhUq*v5&TxAxZ$53)OQRU5+YF#6cC4lPfJliq+LB0Fu1i%W>Zm*ABZ})cZl)Iy4r26 zO9Peht-2tE^SGLo#QPbqap!}Rv(A3HI*)cB3bZ2O z_`nk8gCrc6qm+iX*E^jO(h#O;5&jKAhkjV1DRF&BlED`6cjkkj093Zv6<3)!Oz6`? z!&-;?zBCmLc?-DK^3VsT^M{=lb<8yWp>0w2oY#}YiIGwk@J|jt|KgKq_u~3(&eSzp z^C_d8Y{BS${8Pgz00k#@jX*u8cYD3$P!HRV4}|?b z5-wEKsrT^!B$PrX9t6QVzbO`_skJj(Lweajlm!$bWBjgq3Cc^5*~;4_(} zp3eLZtQbCD0~{Yrf*cZ#%TY?b(m8iV2^&U8hmWhg+eGp6zW2*B#v4pMeczsdgoG_s zxCNi?^S;+_W^3e752z;B6=sOE1#iPevhR1aUY?8Bt=+?ques|xsQo*Hv%3%_?oc00 z&ObB))E>IlInnFL1nd4$vye{zh~vD!xV>}R?UUYau;k*mo(DX;Y?!dBEi)t)Exx>2n<#l0=1R269L^E=MU1d&Yc;6VebCUw{Q!*KRtHE;NLMNL307h{M4rt};M% zT|H(nZ|m)erlKJ~0}Nc7e_;5W2Gqh*yA~I`IDqZ93VSR$WNHie7caipvFBhkg|TyG zfN#Ujr@^8O2`9#!qs z)o^-{YRPpuzxCc~nXPW2%aS4~&E|P`vftIN7Uq3&C8g8N)kM5N!IUC#BNl5o9aJEP zgyZs2gN5r$gTw2p?3+cc-(^v_uiJcT^`)KzCzXlf{Hv&pbi`GeBRU8htY|H(*8C3D zOB@LFTKI2~{jTqyvIG4rS2yL9>dDfr2rD$Rd9WvGrUtSFMM%Og6}i)~kV?(Rhax25 zxE!TLSj8%O1+fS>p51#PIH_FIEqSjr`fkz9fyqRy&G~jxMQ9#}$(jy*DAUt^Snx*b zSp`urN-dYxb8KD4I?@Khl^Gn*HPA0 zr@xG-9I81`?r^NZ<1l@jV2}{g*!Vx%@f9e*2Z?U9@kFqWN6$DcemM1Bjxm5~j$Bu$ z18F+MkHZF6dt|X_M^ERO8y?konp%Am^KjAoJARm{XYfHtpv=s~P3OXV=4zlqfO;f+ z^YpzVh7Os>#|Jqi9G9b%dS^qvSW8i_Q~T+;3evxTXP@uiaA*&=)iHi+E)N;ep2_8mn|VE?sAql;RhHG;@S*k23@bHW>D_33&ayDlIHTu*(|Dy$3nI_9UO7R_PM(MR_5Wgz5b)5 zsArx7%Ay`n3^!RJ)6^wB&TODa_=IEQg7?4Dnm&+2!f`oDsn>0c*DayxtLT!^Gw{n= zs$zKavcA>}G{-l5>S-|ba`Mekmnx7DABDNm#sdY!;o#H814P=@L%j*xM%^|Q_4qm9 zE$8twW7|x0*>=-?y0v}rS|}GV2OL~|jrnU}hJTM1n1&AylXlNtx^LhHiiG2g0y!ic zm!p({GqzYZ5;Ab~XzSyz7O$mX>{q&WY*m99sP9wIkdT-;T4sR);&AY3;{hV=>S3To z?Y=op&Ok@c?91@PpQOduk zJA*`@g@#!f7@)3tZItFQF4UTU))WRZ!IC z-v8gJr-pho{?C#0$p0hi=k_SgD2#f5=ftRYYG-mxso^U$B%CA%$CXm=cA;Zmgw*rr zevTxRYx%*+*}51^J@h6jdtUaU&YN&){TxZUQ!m0{M}oQ+ixl;Kpvt8$boLku7M(rb%HiKrGpJB+hpq-AJ7ucT=3?`W4w-6f9<$|f zK3nTCKj`pUmTb6oTWDHi>mANz8?i9_O>w-}Gr8!LWAE56LeOx|8%;`4=iWg*;$5E_ zo@8Bqa*zhj$73EtZN&=Rpy3` zY?D?A6)R%(uTQHSSF93#v5L7D4Jd>ZV>XlM1gtX9f6#MCL9V*!JGkU4nHfF8DGBbC z*3a5`@A09)1?9m->Am2N!g`7NofOBX1&1E!o+p~RH{R>g&`z^7=Nbg|iCX!@F^W4x zv`5r`r8q9<@ZICyflO!;t~=nMXJ_=TwGDL z{%+fYwgxV=IdGADC;)LrQyhf{^D=4yU$ut zK32tc4+rjd&2IP?2~d%<7pb8`IJm}-*R5lY@zuv&a9QAU;Ck|Zj~=R8(rMM6U3gxV z{vm7S*a6tvlIucNkelWn*loMT&chZx@>uBP_Uhv3`|Fs8Ka^i+_vh?@P+$H&B>}es zVn4B-)T{`dUKYo}?^u}m7(q4)J!iH9s1yX3PBGGJ#Pnr=9r(f80Zl>C5wsM?53C)~ zL}tw8}5a9oY`}MX#@mEA>~{0qKmUI9_AzfKK(2s$DhJy>NuE1aLc$_28XT zc2x8Mc9CtR=2FRF)eN2wXe}hM-w-rsQTU;(9dO0c}Y!cYJa2xS@977iR}spO}iYxV3*a7K` zrZ|>4(Er7{&Kos&^^&Sx)wbj3$HEf8?Et$8vtJW@H{qwRPkf_iD~eS&h8@u97r2Bd zzJ;?5-%;!*`NaJPDHi(T3(*b)|9g9j0z1I>^Q8VCaG^5u)yHj+Us&QIJJ57o|BzQV z)XrNIZY|EYU`kfz;Yz!|N&ZZ&QP+iDR*Y3Gzj%;j2XxkjxcLBST?lfmW^Z)r2gh+g z^O)HVu%*ZUHJ%+vqSomb|4k{`LtYKNBSnsb)kO`wOkPARm^MhR87}gQ-Aef9{yNz%Jx8s zkK`HE4hYrMy*IB5{Xg3uxX;=F%^1=9_bHCftR2wI^m{mAT$Snkx==XVvucWpR$5XV z!#MmOzoYwJcZc`>wRnkdw^zIN(Bi6FmXGoaJDlIL1E7^S6_pC`(W2au?LdJ4P#;{W zzrqekXEenzj~C7-YiKzCoSIFL_cLD6 zeBczPk}y}K&BXa!+`MSy@qg@H2Uyff*A8~C4SPkw-msx!->3+J3Kqn2ZHT>rqF7PX zYr)(!_$Y_Fk}ev3JF;7nMJgiXWTFjD>K^_IdWp%x?r56-!oqJ|7e!@;MC2Z+3@qpRJzWd8#S zsHL~5CC-T6Cf0-_M^@WgpKr6QY5pCj-}Vk-Z;l9W8D*iCVrqerOT~nKD`q<`RYQfq z(t8q)Q;sCZP--3e+eUKQ=zu1({_<`zR-ODXKFqJ|X!VH$Qkbgp=gpIBKK$E%IOQ89R#p zPIc`Z={bgevh%%F^oMcu5S#09c@_rJJD$ew&Q>^x)oNweWE>`LLOb$ndJo-elTxJJ zLiO-Er z04ShE7ej}egny8bls6h)K?bDZ;M2qdMBdfGztl!sADD}Of(Fbv|KH1Q5xZK?|JXL+ zpAMahqo)83*s!DHNDBiMw?RR3k(fimzhm7+kVC?8ImR-ueZs}sVg`a@+I0SV>j`&4 z)kjh)pHa*}T}IWAkd!$ZW?C1yo-(kirE#h?6AvSug6LvW+J+$EcWr(0jwD0f12? z9B)&C91@PpF_wV~K0GQTW*~IVhQ9AmDOXsCdd|N$1}SD>T6%$y0j`Sh|I#YMLp6RK z3{=HCnE!C6UqM-F+#EZ~d3oaPuPY8b;s#*aJ?i~dj(V2vpFzz}n3=^e zL&9-6#!|0h;x)w8956aTO(OW>-8qV(-+KAq11#Fx5SRVxh^d^-5&aqPlZL->cy zJqR=EBwR?Fxw!Piy9e@%8y6!OBc}3vBzxDC!**wy6>PEFZTl3PvTwH{oNauvB+O++ zifM@U7U6!{ zw1I>m1|APGAPonfwmb-tx;kiB-M+$SLuiQ4GwAb+GoW`K!vF2nf|vK*cU#wSyMM-V zb!wrTp$|B)#om{4iqO&rG>C!F;KUgMeLxb9GY#aBa9obD4D<==^jge7=mP=)%8#mD z$s`Pfgv2kbcr_+uKpGCdbYNgqwLZ4yVxX|GR#DH4$15Ey?Y>lXyG&W@(H`vcl|9;^ zg@t-)9)3wqIvh~q-^FTpXMlPn93M^r>XC3n{}8>*b<(@GI711D*{g?wCg!8AXcr^bg(_}M%nj?XcW!n=pQ5`0PKY(p2?~8#k<}~Bd7(G0vAS5zz=S!_<=H7dDlaJaS5Z56QRNQG&;kl z7e{V1j}On*Vbt<+5$w%#9VZ3JQOh!EK+;-~e4(?eHer+lrx1xMfaBBxIV2pHZ)}6{ z$=-}X;uizP@?paI?RoD+#ndarmx#Cz1`s3!e$Lf=Eg=KaaPVp30V40}&}vs!j5KHy zWPPI}c(^ztq|uU6d?fq!ryKnm>sh+Zk|CvDCFIY-Hhj2AgR042s>$)sGFD;`{|4GD z8ah5;C;g&rxiG5t95vKRY@2n@Ulbza_^ECnhlJzujpg5_wbN^e`PV*I*?cxm+v$AO zr@s!ZGEeQ(a^_!(`Ii@-TE-$35)z`Y7aCqc2BhKO)5HTr-qpdsK6Zg_MyNheb$VTK zMo9b+P;Cu)Ek5{}C; zmU?Tw?DEP{4-TOD)bHSXvrrE*AbyiI*XcmLBQ1}af2<^&vJV`c6zCMv_4MHu6l6de4n9phK;&H=T5rqnz8}q{^@Nqu`N}+xYU4el z#jcpYZU+rqUlu(D%+byGQa+y?1JiY}%E#3=&p)c~Ox*5`U+M4%E>@Ym@YZJUYdh(i zlAVhw3h=FxookrAz`f5@{akw&O~OfXaNJl1hI9+dB4*%Ur)!Qo>9UJ1KHyT`N1h?- z=kYn}D^`AJmYlR$B{!cC#~fi@QatBpmQ3*(0Ke2t2L|>jTrt@Y29g$~kZ^HE^)6Ov za(Y(dp}}7~Viu3gv205VTXeHzv5K=z#0ohYT83YYQiQky14T%}@zdTw5t49RjH9>YG48c34xz;HN1ihNW;OWi3f zVR3_^hNwY&cvGKWoDsdlFDK&S1F5?GopuLYXtg1*#u@hJ)gHbV<)~-r0~$mv-?re0WMhdHyJgwvHmT+8*!w@95~*2!av zsh3N54YjEP2?@XzR-HJsXn0(=o|UFWVLTA-J`-9mKzu5 zUI9G?^Z^S5cIaebpyB~gU>e>yY{TrUeza2rO~P?TfgBQ!%Q2RL&O1LA6*KVF&}Lb_ z{}WC_+izLG$YjL~)MYIT2}zlwVHRXS8V){9JV4}K9Sroon|Gp{D134rdmt!pdW)JLKN2~#%R|X2mSw(+T%)hjB z{~!Y-UdiJ)s)K(Yvd#=Q7ykqeSf}BK-A_)9YQ4nq;pR?`cjln{g9dbJH?O4}1JiW? zM$bG%0zZh2&qMHjeV;+iIznm12zU^On_|PxQrt|SdN9_j13V*kHp!KE|FLW9>{63( zk{ld2mVudngWk0xgZi8+b32Kp+KssDE;fy+N=vTAwk^2$-pJGH8pRP9vc7XOao62MRTsAf0r z{3t43U2eb}mx{#_8lQO?-A8dtEE8X}%mi10aLHfr3DHtqpK6ELhQ}kG^znS;S7WTU zh3`K$5U+(p7Llv>cLvoB~Z~k$%&r!K1*ng=9EGPf{Z|Q;N z{1|9QN&7Qdwf%SGzOaOi^lMBHd<*1eEe>IN;46W|O^@(-Gt+HDq>0Imm4xxE>& zdeB6=*aojvy`BUeJUR9E8pV15bxydS_IDc+f*7QD(s1x;%YzW9tD{GLs?d|NhV%!p z?|!;0h!EDpx4T)wEAaB@)@w#T-8uB~kjiZCKb{#AZf-sBpY;cbR+cdRoFZy8CSASZ z?(*_V-h`)=^;E0U$>Cor&-}@RH{p*ku;yLSOF(*4v|A=@tA#g6{v7o`cJiMWrw7!7 zC1>L$tM+nwKs^>a`R^}o_FA1uvVJmIm7T}4U?=|po((_wFZ9^c58@9_n)CqVN}38Y zh|K3|kmTvedLT4vcqTkke}o>8f6!!A4NebeRWGU9sRe_!)D)Kht_OOwV)cN!8-MWL z!WxzA73%?!Nw7*pP4<$Y2ZVlu$xr^9cB!b6xk;_|Kd&bQT>PMVPyX{Ry!_C^Ev4NK zoH;oz-?X7k*qeiF&sLJt10MWWZa8~7EH~hWXk|J1Zy{gk>_!$a{f}?E1e1~^9N&(K zBuCTBWm46#k;UCFRqu$Y7WCKaw;!4hq2Y9}TsTZ19b=UQMxkWX|d82dB+8eh0c+ckheXna<6n&5)Q0KuHM;>Qlor}X1-|EbcXx)&4d4Gaf-cpX^|#ZZbvYYdVla!g2Y=@^9R&19QaugH_m|fGW-DveP8| zgM_5K(eMf~APonfCLSR2t`7d??K@+$x%ek&z!PU1&D#(<$9?w253N^p>pLAi1!%xK zjj!&tFi`PwQ_x%_=8$lFQ#Fu7!f`pqGH`=O^$ubNf?|Tb&a&JpK14ACbuBlAgrv;T zFbgsu4F{hl9w73r4hD8V^4$R>{eA5l%)T5iNC{YqU1u*d4t3fex3{2Mn z82MrYR9`VG4HxbU;!+a)tQU2pH(&nO`(EVF|w};hjuk~%F zP0H9+b$c9ZZOC>1w#*tiR8I9-c6>63e?k0?PXn>z$pBBpjwh?l@AyQ*Npf)9SpMa| z8!=nVzwG=*OriYgU?YEZ$(|(!s?f7K!VMjt3gxv4?{j6dd77$)ZZM6jn2~pS!O+3heG#q@Ic!0>eI@I9Z1wO^i zr3Qsjn6?q$bBtK)=eBx^r_-WmpCt1T$5!;ZEXP1gAJ8BMLW2`$2=oC-ILXC3nX0EtraIF9O|UV~9dr_D}1)r0WZ9`9>-EE_b9S*Bh(51ao> z?^elLdHt8GIur1cl=}63`n1>1bN35)5brm^@nrmLp4KsB{A?Z($LAPGax#gFLdUAk z?C$@(5mSp_Y^jDLj5g1B{ZuivbS;=Btm+i16fz)w4$ZZ`s)d+3s1@dPeyjp&2@9jK zbuR)ANh4S9g6YX$8#kGfdf5F?d+%M<8!lmws-^;x3*?d0YX2p*RN}|bzSdX%q;LTb z;$$Y9fLfr9@DWMSY9t(|7D2vEBq%t2AjwcH}x@VPQYGoDbMEF_> z2qYu`?1d(t$*EN?CtKY6kVy61HZzRmdk&>v*K6^j}NcIFNCCzg>_+!qa*@Qa7(QQ^eHk-!#InmtkN?@}+{*Qr z$99jsmGkuXD}hP_7OPx5)VZ`A1JiZJuBKy=UrD2z@0V5s_=JNy@V(Jsqb*XqGl-KQ zv>!nrjthPpdneBnyC1B)^jWNOw)f^Q!3+cMVP~`e9wD(Yrl?J4!s>N65=oPAk{ld2 zmVx8WU40^E;DU+mAH<)Hq;2>kQbtaj@mVng(Lg0>#%>Xx5LY)sRr6KLEE_iU87;@l z^{#CQ14%P;B%FI7?!Vp{yX76edoLSvyLFgjwk7>)H)Dw)nXwz(z1(s+8d?^v7^Mht z1x8YMfa9Bif+8g0xO`)2*rieOZ!ryv^NJAm=)Bjm^1U?C5NIZTJJB^HB*isfPRM{X z9DJI1fXKT#Mpi0DCIlHmLu>>kUD}|f_}tpp2+w*cbI!eOLI-c~ZTz)9JCDFETzS1Q z^o$(;EPX(O_y>H#`)<$&B;k0&66BC@T#m8)o6zmmPci?XYX(Q8yqdI7`HVTc^p$

WHwEL@<0X2sgXP+YY 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%0A0ZeP-G$ENpv`0Pm>i}6%+d%L2~PnV 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 literal 798682 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%0AU76GPXt4#(h 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 diff --git a/assets/logo/logotests.3dmbak b/assets/logo/logotests.3dmbak new file mode 100644 index 0000000000000000000000000000000000000000..94756b83268a7cad0818dee20d0caf4b4853b78e GIT binary patch literal 680797 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

8t1hK9r=mY`OwAzH47W7}( z*>;MRkXmBDW77xSy5U~F2hVKi8>S;Xjqqbbi~}Fzc`e}A9pJ&~cs!@VsBMB0K*)ea zcSBx`-TDb&18>8C$_5$!4g>rer`PMCyo~_k8lY)BjsHD*8w^nWd-T?}Nfd`a+cFPu zhq2}g(Axm@ZK@mT{|hR7RjU1SsxyQBwRRg{Pi@+Yp}vo#8o+S@>KCi-GbmU%=45jLzyQZ8*@|5W~F1)b=_k ztsb^|$m-$x|2hTQ0nZ!`|C+`JUtQeVK+TPF&c+3_EzBG-i176WezXkUUN&=hZrG46 zAARFkis|wj6S^Epx%B*D-O{mNeH(nYx@^}aOqcE9sULe@_?uE?Q@9_d$-y9f2;hUS znnYnyl`8+F(E zG%ORa(v7t_oc1!kt1IN=xrYbLvZg5bf2Rx{5ezfOHXsB#w5KQ-kDMJB$&cJYVy8>{ z7JVn}r*=OhZ};nhdC6Pw%mz(rDj|Z!#U|ij^N7h1_t%>GK*;qv#>}WMiC}ba>v*y9 zI`{AzoBf4y2#LkcP?9WoSC&`J{u8oTF$N53mA$Nm^&1z(b5AM+G6$1o?{ zVScTIG2HYDTG0rY8(0^AeG+H}%uBo$SPoh&o~aF?dL5MY->jAY(>l?s%dDnr<_D$k zZo@P;+l1ymoIk4H2i5fj_+LeCV(XTvq{L=NY}b0L33e@P`@?pv0k3G+ zdUa0p>Lu!VS3@ZI)muY(>5WE5Vd^r~mBRurA6~m<&(!d14lVBY?-qoq3!g!&*OeRU zrcI$QEPY-F=V}~+dJ6hywc}SG3mfP+uTM8cn{I41jz`Q?SAHN^GaQec>AL$&pD)gh z9Xm{TFs%8EuO+z|&7mwFxrx9RmVtg_)O6fIyTG={ri|P;$n`o#u5kz!y#zAeGLBa> z^`rauZQ#A27q7w}1^_RZ0WH6bM-aqcSs(FAq&H^;?*p~*cJNozb?~QI8>b)R4uk24 zKEL(y@0EU84~7FKU$l!C#b;c_6gkdB51QlN=U(!G?URoFYx^hX?)N-~c?sTS;Vph& z0$px2Xx@Llc6(jxZPT_Fy#USYpt=7JP3YC=?N!%iubRJJHZ|NCYK)!&I{wfN)062w z%Xj(V_ojW7J?UbQYN4n^mXGNP+YE<*H2~YF*26znVl%AAaoENXkN3*(8Xa#g8ttx) z?dIY2-0R-Y!}D=7&^Ny|T2EJ)D>n`^Y|ld4Sc4U3qhWVr8Swwl4IFzt)P(2Da)`mZ z9UEay@fP&FzhNg1?@f+`K2L|f;(Zak!)CM#O*E7??rHi!Tt|3%6MYT&F?SkaD2M+J zhc~R*3G!Yyp0w@exIfDf(ezF>Qh1VlzUj|V<<^6pr`rm9r_-FT*UoW3CgR$l*?z8n@_Qw>rz=YyR zt9*vped+Uq3wETsbo#L$PjPrB-UX=K$lrKL*7W^6qvh&#QrycRdL0ypW#}N_MRvfA zX23HR<{5u@1oJ<yKZ)rHk2jOjm%@D5oPT1!k4Bg0*qlYd3byk>U zzG%2-WOQ@2|Q;1()vZ`A2oCVCj!5 zcRsnCCa7)qV9Ez`<$_?_Us8_DDHSl(2gwghizyZ#1w*ogLtK85Nq(+=imRXE>KFW0 zB3{tl{ctkp3yE_}hJCVkcQWS-?SJ|Fqk>CO!gRm6($Vg5Lg)g~324rSM>V|T{@JyC zFYNZUJ&r$|_wwx5W6?F7j~G0SEe$zK3E$eV;^6y-4kTyJo=VF$uN890;m5q*?`-#@ zvpt+$``J+3xMj`-8}s;rjiuqZznflHPGYQ?f3Ff;hX}m)hMieQ`!DX;|BJBs!1(^s z?tXpn`XKw(L^zK!`&~dhT$%RRxBYg(%Ip?Asq?K7#QCe6wVoCbpW}T{ZEsG5bA<@| z=0rG$M8dvBgYZtm#)iv;73`TH6!78_n>&m`6Cb=Hh)}1w`|Q6VY!+~paFdWL*(9$X z%Eq(*-SoP05)2zKywhC$_>}|K7z1g34br$^;~wO-X+qv-JFjlVZ8kNp#mvmdjWt;2 z@qbFZK6cf80>rb1i_R|pF;+^PTJZr*jV+ho6+u&Lp?ge7|uUENTd$~i)Pn>pUbm-|#v)(?55jKv?^c+o?7Hq=%kr@|i|18@=p)qx)&?x5O1Uv(fz=Xb! zo1gOO^hC^l8&-oQf*Okka4(ezxbVu(v*xY#Nfd5+cjpy)&4J|f!X5wW?I{-Gf-ky- z$!RFF0a-XdEj z&DrKI#1(aIPP`xyl6Jkl`Jv~JQ%;y4dUW@&)kd7}h0Yox;SV>6JaqN`Cmj~|{NI%b zren)@x9^&cHE{(1YYBWK{6Qn+`$)EePsVe0`O?A_uoi> zdR%ZJjFLYSbZ;cU%OyZn_MBUGq zk2_PeJL^OL3EXnYn9lvJO5k5#Dgg%9z8Cl!B>>;v%e&9zkQn`XwD2XlcmeM}w6S_e2(pwo@5 z1DYfS949mC#Yd8bFJRsfVXF5xp6f-EhbfygEyt(xJ}(UjNlJD5v9a5xBy;{trGVy_ zqGjd38{x*5AyX;Pe*5IkyKXL>8a`KHcdbwwZwkS4?=O`CogYric?BuJS6bICKElN3 z(|O+{`Q;WQi7_W%&crfQW!oYBl2t;WW#TJxF5 z0o@^pGBYD*CqDI@LJ4&NmPdxn2ucpG+WFPpu!TlZQ!mTvnXLV(W^ccO6yOW;fSCG! zH@&W$#8@N$ZXyLt_Xl3qUHR9SF2B?ogpoIsXaWB-1)C)n@c*%3h3|VkJ!&!ppZuh? zD>8d5APUxedbO!i;Egp1FbaC3jdAP@D^)J|g7-!OG>Ve{b8FDADfd^c{^0tAxLrGZ zR<8ZSuxB%_3FG-fZyJes4f_Enj(vE`bR96jHn=mKJqYJp94R4e@D?3*d|vF2Y7lQs zC5Tn@N3NrxET2s8 z^%#OZ^l*qaxS_Bq{28}@icg_~s}f*z;SlfRSuMm7;BbZ5t$+uYq1r%Go*T;-RPIbNvIl*n}Jis-qXE435*h zV>%6S8y~+U9w_;p01lr*31Ksu!(1)djOfRO8Pv>hz!cY$kRP*jY02&O)Fa}Z?PecU zi7M`->mdCZPQ(s|=aDf~KL`-VA5-E71|PPRTu8pRzUNzGFHEHE2W~a{8W+Ped#vGT zFa8rf!}0b6a+T&A;QC%1+qpek5x7zxq$XJ!lM%1Ck^D=kO@!W*nx+LN44CdaU9H1IGJ47p@yw zh#P7Whv~6AX8Qi$3WiTP@w@dkN$}K;xH)WL#uqB#1Jl^TJS2B6YCwjDAVdQZ7=;#3 zi`X|hp5Jl){RTVXf1ein?C5mW{+pQ3zIMA@u=1w*332}79K(*Z9`JO6>*z;Xn3$J1 zFit+$H@`&qY+T53`*rPhj}w}{*CFTSHX^Pj-s3yQzrW0HdcMUA+V~FIk~#i|C5br& z%11?jdH6v#T$j_iQ&0rvESY>85KiX881QO&m2 zsE_!YA-==BZ(0oxTa_U2{hxlpsf}@v|0Lya`1y~yEv1&@FWP?ZJ;cA}6c$salwaIx z_?S18Zy3v$4Xh!t!Jnq*dqepg+OX{WPg4HcpW9Dr$5@Zw6+0ue)A_DHH3v9MDL=-o z%YrwQZy2DaQ*?uA@F&44!5hlw(DR?B{K_r|iPB%Zr=EU%NUms=KcfY}VM_T|^=ZGo zp?t#ty`lVEPeO zaZg^L-E>*tQNOH^W7rbo$K@qpjl};}2(OQ@PTvgThI8q43qG@Bq8nW_`Q0W5qH7OZ zZ~JnE(Qspi@7|aM3*Y7N58r7^5T7h}IiaDtT8qkZ9AUbi`Oo&}o3F=q zR|FMJ-);SE!Y$TeKkUo_Oosl9gQYyaGXvktMG!~My0)obI(8I76z4h``;+nQ{B1a< zvHlctS@HO!bK$0p5C3C3JU-uW2x*)9T>nf~|gb)}1ZWb)J!8O*?dt3qB)05G)OigMT z$kh(s{RaJPxS;3aeU~lAzpZVwpU=2ja6cb$;imNSB$pTWGlUEOc|SXOq!)B3nK${w zqO+c-*0_93nBmSC`ibw*#rFXi`#DlQ^bQtHM)$Jud|7-$#>9V82xHC(xPS{c>|=+6lKo#l0sD5b z(Y|dz(ZULI)nB>1)|_wHq~RNCz{UAw@T&yI8R`m~Hp{@Iz1A>8&2S;?>T>?o7J*@x z;TkbK$0RJc7$>=s0fO2)z;h>s;dVUX=h} z2!k))^)Zk!zI=KR#Jt$`6TdYNOl>o0Z15$YO5c;eKYhL)D1k|;$zA_hoBY{7)^$vY z4ZH6DNt!9N@ZMP02SfaeT~8@_d+gl~xx!N;THP+n_wW__TsuH%{iV%I0m>TVUQ`pI!y*_ia@szcN2>oA61t?S?Ss=V=!bse+i=ekas z0*l`p>-tcLf3fRre&`orR@`e`(0-R;g1C|yrnS9V*PrH3&HKl?j+th|u0z-qT6k}) z>%$=a#jbz&_`GELg}dVtF2}pYt!g#aw6a(0`tR??O*QR0hL*3jEAai!9N+f<_UFkZ zVD{(Ag&E-M9l3Cj)N12+yWhs`Dmk06%Kzi^c*pe@FyHUbr5mC#`#L zZfMy2PX7o1m;;&ufK|Ay>z93zEr=U`+N=EAb#WJM&4Rj3`bPl3e8?04ysvB~_Pak+ zequtDE^}+t@nWBtySmDM1OUtpOaZ{^`uED?o+&4feRg`%jy@BI=-dCgb@uRo1OQCX z&jVomcFxc3jtUm-S}`ejLZm3$@txEOKYgV6M*zUOs3`zgv`>Ej)1IpztRDaUr$-0e zjNeAbb}n1`j{txdrKSL2BJ_4^Pm8ApeE#eDN6n`OU%&5Jo2mUr0Kknu55Qo<*B_3| zAAV%|%|SCRI(T0bCMI_Lebv9%e*^%mTbTlYXMyF-32dcw`na7>z8Lq#uZPPn{Ip?> zDF6*Qv&gssDnFgHm*I6grtb8h_?yS6JKcTO9 z$1cWe7UrBIxV%_}>&=BR55w>`gSa{1V^^oqnwg$;F(#SeLp}J0W8>Nne_sM$g@W%w zGkz%sUj*R^F~+M=mN?rUHPj2D$>{T|z*a)zyQ$CTYb9)KwE^HsjOF-zT*VDDW6oql zIKy8YyV#f?{_^Kg>LMBjFgI!3@hyEMG^E#ywHND4*_vLr{A|3kzmDabgPa(qAqH2( zVGkEyVQ?i4R@ON7FC4B4KlRJkzbMck8Pf#DDUTxjZsPb+1OhT>4mvI!XT{GvgDd8G z@jT-2^uf13IlyE5?iWM=NzMchJH8I%8=wc$J}|x*X_5=qr9)uyAq&HSk=6h+CIZYA zaTjvCr@w>C&xJ5{&({rby<*)^eI3lWel}y?N4UMH9#{JsND}I^!;OH$9!7r@1k50w zzv#j2vyH2kt-V!2|AaA7f3eVX_&L3ixtPX%&(#RY^$u5EpV8P9HWcsw}R7IYNhY#(yH z#NDpzdi^{!&X^h7_GaOHbs0>;IE{C8dGPpQ$8*Q$S{MKcyVni4hBKJ*Zp@2Ua-}dY zUciN$!i#PA)}U+eaADjq&x^<62Eo-qX?DM8)bjSX#N+pleCNWZJwLVJY^ZG^)API- zFY`A7>RlnFL*>?~xEj1HF#0_2eOqXJH}&~^Zwn2yYs_T$%i%?0jNTl!dNNHZPth6Tnxdncjc``-!k%|TfV(`(|r7@7R@s!(CX{{`>mM-d3dz zVxGJ76?iVM^I`(;+9aN9)=Ay-lHDJlhv(#xS?#xhRU8wS*^4}P4jhce+U{CN{wDwU zC=B|GJeSvyc)vM!;S=1vXmHJ+-Sn9mpNsGa6^UwLIspx zrYe8KsK=~=cMZdQ9QNzt@%UlKaX>>tT_R?>YigcG;tY-HyQ8qS01orsPq}bY^xbN{ zH6XT!jqu(V_t^8xP8A3Gsb`$Lb9s5Ue&L(Aoo76A#>0}v_;m*3Ws|3#y`O1-s&0AD zuP%8`%lmvh|Esg-Eex1?|F1djM?ynS{!GhlKHYA#A=AI{herrhf$8CYgX7i%{YJ~> zIqkcKfN^@``N&%q>Xy}WrcLNSd(sS>&o;WOT(!y7WmD^0F2W9wa}I0>PXN=vY&cUi z1N{DtSn*&5+2ov!S|r|mp?G7)!WS(SO>eg8IhzX0|5d(!$7%v-=3L&v37yP#Un{;% z0IU6wi^TlBj>p&Y79$(H(5$0DVXe#1Ff&&H?={TB#~J+RTEJ3dQIM74q=Kmwfz}aU z5-{DU#rq?O|9~@vdrJtLWUc^~I;XjCL#eaZZ$?Y?u%Q!wnc#!`vKK!1Hn#0pZ1HaF z986sg06jywy7)M(*qi>I6KBB_YYuEOt~DIKBZ!1#X?a%SM zY2R^QT5^ryzNooEP3cP#-vG3CiVO2_BO*iPD&DwIpt&S`8-Aj zL(H(PWB+Ja)AwBM244HOF>=>{kz=1Tn=y1v!|G{nX~+RU80$bT6Tb=SGJV&dVKtEJ z0LE$n7j6nxC-5By7#o_c4G`cs4ir8crn4mz_e}q3t<4na!LW|o^!g;cEO;KPLm+1I z#qBrvQWyhwxSDY8relOFROcBDnk!Roec$vtOtEULLr}7QebehO(svygaLf^hw^&X3 zy4wBekUtxlr5qCQ$js!zO&OW4Jn{f{t++5Bh2iFvLOu?UjE7&>G2?e_pKy9WqU1sA z_l7iwxVPY`=K%bHRf4$DGVU>77S|UJ`LO%p8nX+#A?&p6s3wUbAxaO(3DY#}iI5Es}QjF&n1!3R|Ep>2YYkILD{m%uf@9=`HChE4fO*Z$+?G9PM9_y_>=oHN$(`0k`% z{|cl3Nxl+%zsf>>_0rVfzV9xLXnSWImcy8@@EElNLj*x=*!JQ6hFE<)eC5xv>gv&d z#OzB|O~UHN4U#-O+NL98tb-6j7yiT<;n=fTe&?_F$_fq%nAYcW;ik}fcOH2FV>>R) zM`5@dqxHugS*_)5u1`4deQtKx>bz7uDwx)dpOy50Q0tSk`JcTTxI3@6@!aIkIYBbj zI7+G-Z~`M{;4&F%xE<9FLuy)Q)e0!$?!kJd&Bj^hc8(_bbxr9A2Cf5gu8^W8OI@H z13_$S&Vhl)>Du?*}^k||`A{Mr5_y5>C3%Dqr z_m3ZTE7*QT#4f~cWkp0q5EB~#vAYF>vp^BC2t`H3MzI@|wHsS8u)f%Ze(n6T@odcP z9J|Zm{r$a;*GuQ-Gjq?(&hGo3soniBnDE%MzTUF&BiXnwL3OJhlzy<~x8PwYqqUk$ z6Ugp#V*YUukl+7l&5rhI)Q2}y787xw7cq;+GgxG=paMe6Kx-8&r45B zSI%wMgMf-ad*XDQ9aLA^p7~>b&%w55{WeFJ)O+%v`Rx2dT>jm(D~PJBxIK$H4c_uc z+Y@acXwOxT^4=J`)LExJaXQWpsw-{JS)-CXuHGKy-S&J_ zy4ajQ+Ma0pKznL$3>e^YwTw=C;&hxHR9D)b1BUcTz_w?<{;l719Nx0^yvy#*Yu+tR zZH_~(&zhI7&ikY7IT>lUBAH)ob`Kj*;Pf3y*Pr&OsQY`1(@{H0+w*hbUY6MQ4EkEk zXKRjZZKu8L7yYW^rqf(|QXlBw&(-r^U;iWRiEFpL+L3qOFY?i8PtehJ13Nf9z3ut% z^r;cp_FNs<c8ka^I*Avxjr9V%yQ|Ev?sI=dc5Gr zaXQ*=Uu9S+*!CRScw3W+o;J;=ZE`p`v+98>y4UBXilM!v+Oxi)`=4-K zq5cB+#p!7KfF0CNfxZ&yCs6GzDwir)!;Wx0S z!Gg_)3Aj?^3yM$uELw44^(&UOBM*If{9A4a=BTi^=37-N6t*xm^ean=sed+J->SK1 zDOjjQWR>^#fA$+nk8LfeE0CID({vg>EzkcK2C4c;{H1lmaOs?`WsGuhI%*gO;YS!9 z9Km1#r{mbf>8KqgKh6{)>pN~KB)md2%!C5ThQz0~ho`A#5T;r9U64$J)Bi(30!fsQ zo!Jm2a}n_=<7Ax=dY)vq_V>G{MrUwwZPS;A=F${y?2hj;1U=ydKOo1Joj@nVmVCCagR*M*fwx$v2N|er9 zZF0si2nC5k?$l_QAAzofD4B~0@^PBf2R#hdtQH(-EC#97XzI`AK+wHSot2%0M(nZxA z%J79;K}>=2`GN}S5A|^9P^V3GV{yp&!ofR&R-dxY?G(T9ZQ;qmh5AuP!~4SMCkIMN zF=!ei%3=_FSn;0DheJB^n+w1f;`CZ)yfw3r^NZ(T2dATUlrng}Th_-C3=)g32Cm{aZcQJ91Z zWEhhN^IGLM7L%M`jIU`m(5%Ds=35_~J5oJzEB)kW-Y+i9Jm{trgF%KIBc67TD3P?H z6n*EEZezp4oiD?te0Hb!$fn2I7px*u;-?ch9cKsCl`>ek#;#IA2Imbubg^mf8N`icm9suA;Y}WHIHI6x z2C17QsOHpYxKkESM^pa`W(#8C+^J?ytwuw#6@dKW5PRyy+4PMO%lXESk;7mjvxew* z9$8Do>B1UZO7?W8;=&fD))1*@`%!;3^TQH`S1P)~b%nNZ7D}!v`udG?>&3cMVg`CAH-p$7Ln9pwuj>f4W>|feJ7gkpB(9rRyZ$O-ARkYO!h; zVruniwbp)4|94Y<-k=UsKbO}YHa{lCrPh%C@`QeW8PA?n)L*jkv`$V6_v0)+tDLT7 z^c1_R*0ud6-?AX6xMBRI7vnFvNe6hdOIn@o>3Q&!v`M;Qe>sIHX7j=6GQ6<#Uj8P`Q7 z7oT!xM%5`qww^Z{sAf@L-?g&XN9wS6hphm0b?W{ZfW@N0!(qUQ+uQr|go|Y+>i_=lV^i_kKJX{`oIgmit1rPtUoHeS`9ITG+4+lHw zx+Cc6xp9Cx-wCx3-x4y}|4Rq=nFS^jOv`9A2kz`EtC~snQc1NXZeq$fS`bs9Zazjw z|CgT+yXFxSzHE*h{|J3kxuLMCxc%YQY$luHq;=cY@7uM}-fvfNZQ}uxD4k|9ubHO9 zx)Qb~0#)}=fi!gI%$vhKhE=>CK;U$x#G-bTdPU16<3%s9I_Z0^dP+ebg7J>62y@p( zg;f(sRfhS~C59^qve2O*pX3f5$SlYQl4PjID-QRaeaPqpp5IeqY#mKWBIZ+-*Y}EL zx1$aM2t0qhLw_j(Cz*VpoIP;hqtLZMAQPvfM1dWgj@nU5pjE!^Wh8wd+ii?{RwQHg zp{D5rCHt*_nE?pgd1dK(V-Z+^Jr0{oPq)}MdY;#1(}%@d=j0;dX##(DW}cs=Np*z1 z&Mv8K!ces%bf2_#ch>enI?qG_tWbPFM{xr?I32a46vM{FABgS=&Ne=AUa`D>tRw77 z#FVPmSG6Og9}_@dak|)W1p!%TzKq7uW>CM(M#s?gfcv|%+q@hWHOY~sZ_AD;IvD0K zyW2ntL(_;*)+`NpJ+yxb{ZX8bj{Lw5PDkx1#c*Kw=r2NVh;|cO4u98EHHP|j!J!2) zH0t6iqLhos&xaimYRm??7z;ygL};7$`q@k?O10WueqQ3Us+Y>p7*cmir8>e}_w%%t zBGA+yl|>*pFm#_NI6Rz=?l%QHI32a4l)!V*$4Uwb1pfrvK#P-p*;Nym9!Cfj;Gh$I zFaUv-&ZitR7J*!U)N9(^q_I2AT7_I&*<@6&$Ml+oaGq2%F!#)*CJfWvA4Ru@0){vp z?Oy_hI32a46hoH@jeVssgq@$~%3InR1w*KSh(0c201S6tt5DSF7&g>gNF2K{r}NTf zo!soFdw-`6Fq?2#SZC^$3mJ~#h&jH)*KM^s$ThF%1Gn`F-Axn6WW$~dEhZh+xwzqX zpN0j_+VQN-d?EnZeF}OjWcTSV@3r2=y%!KT9cKsCm10=RZSyK2h8}gs{EnZqfOyPq z{!DK8X0K`tbElpMYQaZpHw_d-Crj*d%kbT&o zKmM(^&FC0ztns>V&*V$(_IGJ9E%&hz^rF59!v=3YwlX$`I-8u>bIN*0tT$wTkhndh zY#ahk*D^{*>@5vtydimHw0LhR=sS?Tr8^mKNaA#y9aL9};nvLMYYH)BofO%Y-P*Zr zbpN8NF{B=Uj>FKCb-U~-&^gr^zPEG@k#ti9hTI-f#2a!tb3n}hxV@#EHza4~*k8Qz zQ0K#sJO;f@th$@}ny6Fy<=25vCJa@3!|IGT)WHh$?#Q;%UyL^-aXN}8*gg8M$FYnktJaXL!KNh6EEb5fj zeX#1V2}9N15OCXwOwqthDNaXcKEV!7N9`!Z@RnC_bD=kc1q)^i+W^A7(%?AN7^Y{z z0xBT9s`<|b!0_^`>3NKfq4RIInr(jWX*sX$#mTDHl9h6!qDK4OV>=C z;P*Hogjg_AJc`N@djDW#;1Yt&Wp(gL)p7)!gA##XS2)gDLR6l!ds%#8{tkGHVGF(H zT?iopE|$9dO>k#C&OUX)!rz%N;{3U!VMK{NuHy$JP9f|x4YscD>(9pL5mfV(Y<6O- z@Pei8ALAaEzP8!v^DlO~I&bg}bia{lIrGfu`sEYGOEuvP(^fz^TLBxmm0Z&~PdH(L z^xrS-Z4_?n5{A{wA;WI4gVRy_N`J{3XKBzycwywKN4yH(uz;A!J_6|I?WY#1f61uZ z#h5?cUmhq3a-jL30^)Rt>Dq%7aj2(5;q`v(V`Kf2(YI)(*3@Rg;*{{LU&}aZf1dHR z`qpd(ReQQa!9F3Dy2*#`mNmZe)6RsW>W;o0Nr7ZL>hgxIb`!K)iqsK${RW;1`f_&`CB1I-5& z5T`>-*B+#ZLp?a=@h>vY=s3D{aeAhmcA@ReMjpKfHO#+~s=XwRL$kc;E`{SCy@69a z*{m~@X(w)bE~aHZ>6|lE=i-K6iXGByb7AYV;l%Z_gypi5g9xTZ8V%^72&Pw)f~=`- z6Hdq3L3O1#Hm{g9K!~F@rf1x%txJd{NvoDR@VK2K*0Vj6~9b!S)E zH5zZW0?=^cQ0LT&lew549DDmmuaJWyGRbU^rC9C;&aP3-R=yiOxLxG1%ja5*Bd<{v z7Y?`Shp2NdvgMI|cchp!J-}JkW?jC+9dn5p$DpZo<5MT$Vqjr>X_`3TJ zS0RUE-+bM;tYa{tu^&@4bk23Vfn{DD$q){?f`r$taP@$#fGC-Z7=XjPJ96zXI)~q` zKkPm>B6ph^J6{bL-{DL&b%0`j_;P1;8p0k{|PYZT% zI%-ELhdZjY7QOHe{Nd{LXB_*#9Y7o&5iwUahx&$$P!NX}{ekBTDj-gW7@rRm=}=D} zwLx_2Cr0PcvP!>Q#RhzAHQ)UCOXtHiJgK7)b69owaLKXaG}BC~oSD>B?9>geKZ(;( z{|0t&I%-ELhmAbFL^rXFW~XjoBJ;i_SzC**G$WDtzO{NHrgMFlh&NNcAPp22^e3;giF41 z%e2NQ3r2trg$PE9I34wXUCG_GeQA&fA91IM)besofXzz7A2A>tu}3W(Do z#^(b?I@AN>`G+NP8Vg2ljj@hrz4^)2YP6nxYf{PIqxZI@jzV%#!?yJAIa0pSgrh7R z!KdLc!s+M)4cNiys2!y^cKZF_Xd#ZA%VOtE2H2Nds~Sgro0qtPL>vh)%jk)l7|n^i zM#pi*qK}O%FJx;yKW~@wzv3tGcUz-N{--Q)=3hlqIdv6sxW{{ImzLX? zkmY=un|G|^OH7UJ)krmm`BIOLJ!NpGd^{ZRUZx`CfNVh-!Yz6_J{ho-3; zMgDN_HZgDD_i%b5vV|G^Ax=l_DCKbPLub(zIPizsmeji9W4kTUlUk|fFg^YdDnMPC zx_<`X@LSY``*JvxyRHxUgq6ju?{iZ(S!>No*|4Og{j_Syk7qT>@`d`c#MBM(?}SWJ zFq)o?Ckw_8V@oVfe7{0x8+g$51_8Tj<8^fG2X=6JdZ%vU+RQ8`bc!cCH@o{!a5%R; z{6@cBqg2C~hr2L!;emp|L&mECEJHmk|bSF3H=+1AjgVRwvO5LHRnZLD=z-k|? zo)IofxE~>c8DSH++n}kg zatK5QfCkwF&fRl;@}<8;(xJpQ`wG@f?zHRM6^=lUEtIJa##O(@~zl4o*kyDCN&*=>-=df9`vFUHX&|#%-zD zbY`FWM~~>+X9@)gFIORd8NQ`v_pDA|jn3bLY2RM;p7z!uDx!On*4K({;`v+meb5&v z{!CLbvZi8yGnAXSuyG>>?OCQXMFTqO=fDn5N9`-+FJer^{6hXd6`pkba{e%GDrQ;I z+{UW?pFaMeARK=g?*D#ie)TXGf810|y`QVv8k6{i*C-8T%JGobOuGq@oJ*=`%d;jKC8vuc8llJbF@_{2vV?a4$Kp5+xds%=e zoR0P>!46JG?IA!K{Z@m)#LWk#(eaXQWpsw+j$>-&TjLi9$@*wXS$*h;b*yF11A+=B6{onL{} zD+xCX$`(X0oETwy%*|h~WNlMJWz)q-qsJDN5j)dZZ$&O0D}Hz%=#|fUYi1wkccuZ7I2~sP z)s>>x{)yRXA$qxz&o*3pGm`AiJ_6mlWK37p=uywk#i7R*L@?(-_f$7xE5M#3Brt&2 zn>#IstUK*96uriY0|sSV^U5KO{;y?rgPuZG6iyR zI!awD>3`lbuA>MYPP79FIy#90c5pgsM=5&UXYD;ML=QTgFy|ODXx0YR=;>R1hk}?> z0RQu+0xAG0;*ifL*3p=r4(G9wnlnc4aN38592`@s7ZK}q=0+{QDxc{3pNfi!F`=h= zwgr$upF07F;dFHD26k{dYDX!0^#**XDuo_ARwDXR!ZV|w2NghJV&VosulF#Ei$+H; z{N=^$+wMiW%xd3nWtPR)8q!BMqvF8|Qs|kM8e}as{KxM4%+tWa%lpen60V@R?57tUB*Mkax z1#zfrPn-@hJzj5I_iskKL(rP7pG}*ME$Xx!Sl)4Fsa>t2yUlAr=`hjR!h3BqDFRKK zU1Sjmq}?1_wBM@FLrAvCHD%ewcASn91$J;cYDX!7wbtC6DSiS7PnQ@d2y&qLpaSA_i0Rsc6mh7Bz)bs-2%{4i$j7I5Yr%ePVa?GZufG2Yj%m@r$xeMzxsfI`g&v^!0D4qXZ9F zdti|oCIVFt|G;zM$ieB(wXKc>y&F%$1qXI;I%-ELf!)^Lejp@}b4;UqRI5090_lD_ zrjBX?^)2;r1;LThp@1y50-|ItBFM*SQXlkqz~lL{^f5YtC&%U*SA1vxw$seUJR4qf z@iXcefIz>)k9SKEXj*KSF{r~ovaI5Yr(9_77)j71=~;&-g@naW;w$JkHna_7L? z(=SWYNBMl&?kC1Z?=N0#@6FuwM|O9+*0ahh-kE{EKhdRH*js+0VHG0%r3vnxcY(WHlv1xQy{2p{*D!`VAmp(W)f%WoG8()1hl!r1&%F z-L}HI>VD>K!Q?i>Aitw_y5FG{Eu-t4Bvj|(hJWQ!dG>DGTS%`H^y1^hGotg@yKQkg z&JL<8!;ccQrkV5KV58~ zAjpB{g9?b#A*O2&QpBMi3>|i68!QJyaBp%$VFhq*kedK~y6$nqcUfMvi+X&oMRM5d zo79(K`X$Fs^FS#AP17&32n5p5X%m=!!RaVzU6Zo{^RL}n=CPx;yLmP9{`Z)75*Cf`RomF; z{l(KSADR6xWL0D>0ra`ZJ{Opl!Ra_VsIC;fe_tN>DMT+fyWzU^(7-D-awDY1XPUj<@#>#A>dVmYocZv-dr}0NCO~Bo2&9#HY&U4ysTm}k7kF+2PDhCX zJ2)M+qm;m|JI!K+&JWhZosX^BTWsMh(mbZ8Ks0 z{I#EY`+$%?*bxQ}X!oLBuQP-{CB0P%$rSK*rN4TO(64IP92IaF;Ea3C=>GepaSA_i1GPAkq-6Deb&r5W{S}XypZdw z&*^nGt>$@WX*la(IPDpMz<+Meo+(A3Y3@^&4}{TM$Must)K6VZg9`+R!s%$A671k~ z)Q(aDduChTOGqG$0w>Q*icGMWNv^gml`#*!hJv7Bn2;w6Dj-gW7@rRm=}-@WJr4d? z!&n4zbD!UGgkJ1_KE-iWqgz9g9HvyIk79Xb)yl?3?=PPF?89z7D^@#s%2qqxnStK= zL+SqBNBl{+VotGJ&u}`<4yr3fFW1F2J%#9vW4E47e%!V6;M6U18^81%quTlDd)P!; z&v{wSRsb4E92x+<6E7my%Rw(g=RS8AAM3p&XMj`S#mbciZ0|FZKFVK1@-~q|&ouKQ z%j?0DsnL-ccrl!g_9MX#PDkx1MQ>=$g3pBL!Got^;Fa@*xB7mkzBP9!2!|9@K%5RS z1E6=SL`yF@=)s((+z_frg}Av-x__CPZZj-@t_2GU-F4p7ZH@oI@ja_iUt)UebLzgy zE5)B_>zOS6V2ha-((44h7BV9WThDMh&JL<8<*(V19dCvF!Pc|GPwK>Px0p{(jdik8 z?fNMGaLayaz33r^tpIgJ>i!vkzn=rzt(L8Ks07!JErptTS~co7lI|HnTY z?5-L^efPdYL1M&syr2T&bcpf!K#>mh4E{2IdXXRpL%Hq`@(C+~bA#O0vt_jhHF)Uz zz4^*n3tqL^d0(^y=#c$%e<=b@(=W0JgbpW42u#1=bd)r(gVRwvN(r2>)wh zzFq6bCL0^Qzj*rPGrRR{IrkGlN`*9T4OS)aq%3IJ^4&;aOVojG)l9Q2SrsA0FB?JBtZ-~D$tJMTW_ zTiU;Ixx(~O2ArAH(b(wOiQ5~ErPcnpbWYbY7P&YbrLGmjJ?nG&fCCL*pVg8~Ng54! zJ)Dj%B7oP!>8Ks0=&e~cTJl}DTUwR~m>DviT+qwzrE2u_^*ht@dQbsqIB_UGW#Tkp zOi#bF?fva#;VNw4*q#WWcHi%kero!wGh9I%;1jdKX0mH6;CWk*zjiJ7$T|+@)e0aQ|0^)Rt@%ccJ z4)tJ|*=y=dqhr{`_wp)h$6?K92aWsH`c=7X)KO#;VpybBv6fQa&@}xb3q!yS#V7BS zbs@1yt8~01=&08NJ2)M+uN1@CU2A3+V%XWI{nYz~mvi3m#cyJ6hF}N;jtO>No|>ZhrW!qcFWH2GaOgn=#OV;@5d}p$)Z+m!PRP{ISm<#b z(Oh>Hd*t5W<+v=-?EARO8(vdKA@YDjGxvBVg`vp<%EA!Fap)8ZV1?7sjwRT^>8Ks0 z7(U9|)>eoi4AWryWhtv6omFF~Zz=`~663?;1r-pdLyXS{igc(4!}wYwJdK4R=K-C( zidzoOG0}eioI4wD`;#<=nga7?W&CSb_J>sb-lcZqgP3;vix(j7#SYw(wO15b7}@^` zdP`*g=c2jYYb}Y5B5^v-4yr3f@1f(d=R))b{YUx@Nr)oHv)eB(J{qn5Wn=mlAOTu=mmBCxVl}ZNN(KMU_nu>YOhDH81&$OK3|59`!*iR{oYt!&x$=>n_OcieR{I%vFlv2T5QkgF8?EjoTazPcT zUZ+9%OT+cqu?x3N;PfC1xptr9%ieFoY8X~njJjZKn8?h4`6T18J7;?TEj@#U1x@Yle; zh^?PSGo8&z2P3tb(x%B5Mg9*rTEpq6KLh`V(@{H0`Li9F++N6EAnX5N_CM#nO2bw2 zr|*IDP>}HY`lH*Ppeuxa-*%A$ohtUiz9iJc?|?ZoXXDr|nbK=;?d! z!)~S^fz2+m9-BB>46$#_b2B88&o;l{f^%i*SRb2l&*R+cQVx)A`fWw zW2mbXh9(cF$OED~HNgYobaXiZJRnX-?I^{t#DbMwg&2Zkf{mEA?oOptW2mnq3I#D3 z!vFl(9V!4R;*ifL*3p=r<%iNw$1N~cN0jq`3)d}}@_j^2m(?#%e!Us^WISE}t;P4= zH#T~Iu?PIZ-v2N$Ve^F$_xU7T6QFOH|7?%bgL$0p!9K16r{nCPx>EFVU29fdh+aPS z{)bY*|MmGNbUJBIjXvwtr)uk2hoT2%($x2%zZ|-1 zkkNO1{>5JJE9>>fp70Gk@M<9mCj|676_!p7vEg-3*6ZPPoE=nGie5qIN=Jm~Fq1Iq1ptc92h4(KNlDrm=O!W=SEg zdz-a>-S6r4N%WVADTlX7p=Wx~i>zrDct8t^2B3t~QN+LwPDkx1MX!hV`K&_p;Q1?X z<XC)f*88m4@@&Tl=EF@o)HJw@dtmJ6_7NFWWqg4B$f%VyU zU|I~kWd5jgDA^<8_fORXQajFYJ6_Uy;#n@X0_?Sl1O^~*wCykBKk;m5mz!4-V_e$o zFw6UyxE1gpb(o?jo<)yuF8QiIgKj)S8W)MC)z)g$x$kM20=YOHHO$Nl&Vhj=L>(LG zg^*z(*um+j9ibb{Sh#@?W^T@{m#T$28NcNd}ze>6=lxkv1gMyfJ_@6%&Pyt90 zhkQPh!Nyri7%7;LOQs1;jJo9Tm&os0Fm;=H(jM6Jc-;7CemHl9U4)wGl9h?>^> zWOYP=Cv?UV#(+2-?O1{xoQ~R2%3r_N>q`sygE8QvVQn%$+BBbhQ{T-?HGleUH-du1 z#PD1}1;ptPnR z!%=q=fvP7!fi$#p2=5!i=_pZP2dATUloIGtX!1y*^MlubLErCDwj66z6R7W@FHn$} z9G)zwfH)mud_GX5Lp=oce%YY8(Fxp{GyZw?ue)2Udwch(*>bDR)KLI|6IQrimm<(K z{8Quu(QYFUh0{@@zz5=V)Q(aDJ@O`f5)ufm38o<{w)(vwLkNU|#N_Z~K?TI=5aaWK zA|2`>@Ij8xM~y|G6=c@Tj&+rc_fa6M9M^!!ieLYa+tg-mx z`k*zB9ljU7V@mURCu(+I=ryq@Re$h+SzLT2J>Z|5fcYQT|FW-r+Y8s@LP)qYVE;?I z9fOW+|GAjcVgCzG$Js%3r3C)4-Tgx70b&13A#^14TO2w@|>s{Is#r`-{EacXrq3+v+JP4&TB^I3b`1 z%+L4OsxhzkWp{nzbetVjSBhTMM;E3^dA+0g3N@M?x`2FDx7u~p=oLvlYPDYPEL#C+ zIB{qI^v>;fEG-AU4E1`SEw9wOI4jU;?!+Bg{A2vj&_~&%@Ub8%^h`rOSwlWpDUU}w zoZ!W9dc~A#x4umZCE-c~J2)M+qZGZ~H^+!p++j!9wfOI2R<8~vUxaKVRimfR>p?+q zpiIak1r-pdLyXS{igc*Q>y>#o-}pnm@nvt%+Ow&ZA8b9Fce&-n zVO|krg8;vAstMG0qhDHE&t|a|fQvyK8i2qnNn`e^aDE1P*b;ZEdr-?hznzk5x7n0@ z{NS{#_li?TNfSuVe5Stg!Kq?YaVZQfH)muy7nMN9O`j|KbwZHk%OV!VISlZ zRsc8rvtl#ZOzTi%#*-7RTSwJ9y`@_2xH6Q^tUX+ur|l-i-=Ca*`HRPZFs3^=VMW(h zUv$TM9TQ{Qo@&VJ=XNDUml?H^#OXLYsIHX1Dw$ip5%M=-#+H_6!d8;OU5~7?O}+i7 zPJuvQ)%;PfufvT2M>7Qx)D@R{?}N^%4rMFAq@({EfWHbCAC8d2UxtnW`}QqxvCHQF z92UeKsPxaS;L`MQ)~+*swXxB&Lt9)NPpkcL>71@*>~V2AYS@`ibjA{9K5;rarUO@r z(@{H0(X$AvmqUmiOh^tbU1H$mM=@1j2GEj9xJ+3cP z_p{yPpa(8ZZYZn-&h>G-K4-Lk-`+pCp<~?0TH26Hy_?ZrK2p9?O)2zD(=W1moq!nH zTZA1iIQ=s+Qwnx)I%-ELdR6{;`C5n`Y(!c6>+sx{R^jBbeG}9_=~~~4I}{|mQiXT^ zK?TI=5HkRJvwL)GZ7lSx+2gP|QlePcPp`!;%YNU;pQ}k^4N8aUmnu$ECYuOM_pVQL zTn4*7aXLy=TEwDuloFWo(@I1jY{rCP*VRV9LR34y0sxFgml!CB%R+zP^Fal~=@8@d zfg&C1aek4mBW0~U$aQ*BZ=?t` z&Ace`foQi8h{EY8QQ!k{I%-ELfddYEU6JyEuma$4`MUa-ZR#U1EguLK5MI#yX9Ey; z_n*PXjpYNa*dwuNf3Vp|o9V4wXKc648@nmTM@naAUJCuU)>DcYCWofPs1qcU(nk<(A!Q|$rMGyH=J@XQH68GygtF^!Gi2fdV|+wFr- zayW;r%{H|0#-JJ0F@gs?F>k_7DFXlG+^3ze(RDwkbsBK#oUUbTa&bCpmbXEii2^$~9krvBK+h!yCGR`}2UO?G{RGtnQcpc&{=`j8X=(LAp#rP{B+#{oWMHFu z`k;5SZ=Yr?56Dfxd@FAG{6^70rvs6{W?Em(&)jy~=f}QMCiGMf|2{EW&j{3M1z&Fv zu&ee8td35!fE}EU+EFu~(oPh$~i#n#rQ zsc+MNUMHMvyU_EHMeyDm!IaL-yyVZNog>Ac$pgyb4>&`)f$<$qM?D?b!Re?SrTooy zsWCvv9}LI90X;nIQ$IuagM!4|@LWL!#OV;@^MN8A>fvufjzUJe-<|V-Uh7?AKGyg| zEcU2&<$XC9cj_p>10HfIZ($-(_3#fo7mgg9?$*?M`+~g7Nw}cE4o*kyC?zm^USfxk zKyXZ1^44x!zxHzS!SB6+stHWbQsk*;y?bP_og#&vY34UDDKVb$pATXTnk01_tTk%9_{(;>#^14TO2gWm1R zQ}fC}4|bEu4TTlK?K-n!GugcC7<(o8T{h?VE8Cj*om>+^>CDVaw*Gf3N%3d8=~fnh zaC7Zpq}K_01!P7PZo0+kI6J7Wl)vpACj|-ltINLc;nn>E^$(0&Np8^io=X>hIMoe?4w|UJkk4u*2wALJ8O1m^~=*-SRpHTtaDd(W@knj5=U z9Se(iOzANFV%NjNSBk(tIR>;79*yqjv`zyqozu09O)gGH4KoIW4ktm=aPIbF+G;^K7F zFs`ris|gjx{8&wNY}M}f>v{bCvvDN@Ry|mb*HNCp4o*kyE9LL#Epon)zjFHvhE)z( zK@8aYYu$m-%gCVeFNUk;Pv3nw1F9YMC=y;ulS$ABlyW+j_2RJ{rTxV_jg^uN;yOG&swjyQ*v zXxDT#fzwf}zz$AF?I^{t_t&x)g&4*as}-2#`f}oT5zB~>T@j@A#?YOrG1NB(go2=9 zn2^T{Dj-gW7@rRm=}-@bP43-sFgk`dHHn^nl@eQSBkUTtJsnbmItmen7QHhqm%`9A z5R}y$1>8`4@=jS75}UM2$4i2adOfg%(^30MF`RXz-yk7|oqgI*ynVaN>xk2ZMsZO-J4F5$oWy|J%m_JVGWs*SqmkV4PY5tW4= zcrF|=I2|4EfgPNV+EI$$(aw9b3DE<`bdenheyeV&{?UW_wqZj-IP{hXYq9j&q%3q7tQ>flx{+9k)D*6XZdLpNn=(SkY(kq1mEc;4vmUa^yITTs(F7r1mz z*D{v4I2|?YcyM}-xlh;R=R2Z+6;4MxmM|W~>8Ks07~b7re@2KQ4Aa6VG!7o|VJTVa z=I}(-9xy%QL8t(nY;h<)W#TkpOb>>2jt+QfEDSjhxGu|)5B3+2+J|+^I_cliC769) zPZFj?NO{0N+4=m7ccMLr9k?ZHuP8D(;qa9Ext5b~J%B#hHfhwsw){@Ckh$G!Es2dH zaXQWpsw+jWSD`20h3F0WkMtXo5Jm3Y`siet^`YeC(M3M0Mo-@}um>^)5lqAAKKzqp zD*z2A4h?{w{kwfGa?nGTDNO{_+U#p<|`cGp$0%>U<_K=;@5_z>A^dHPF${B-p{}s2!!~mCds&Qg~qmb^W-y zU8hKH-1mM(<~Y^p>3jAB6ePS-g-h@mKJI({W-ciQJwQ!vC_EtC61)|g$!6g3hWRhw zv~UVNx%R%tP`7uK&a6U|x<`C4I)79Tkl%Ezv!mCJPS*WT%SbxEkEqVYEo~e+f4BZh z+cQkBlkkY|)4gXD5rp(QLH~eEi+-@({`lp=C<3SB?4Y_*{u;QOw-oYsHoR!<_zO|Q z!Ab)nJ;tsi>su8XkuLt&Q>e2EJAo|-PL(*HMzfu*0F#dXuXAeA3~XFauXBD%=1y|> zLtLCecA{Ca)w6M*m~GMY)t_2ycwctZ=g;FGP&&h(&j9mbej3emHYXj7)M`qbCSMf! zKip^yr=$K1{2xw7?I`7MhTq(1A%B6a|AX28MPsivQO%#eo!C&2@cI(^Kd68>9byLH zZ{fyHz2)#H*Y80-s3H~O{2w>@(x~T}#nwySIv;ZGxpDI9&UBYlH2LyoU4rChm_IoJ zq}`J6u*9F!Iv2QfPS-N_xHug(j2nb*C5j15zTk8eH?V`#Q9DX8^osrxE5r~cUx0!f z>oyC<>yO$KXJec|2 zD%N)C5o3G6zj*Sc8nX|EEQahW1ARNPKMf{ja5~Nosw+h=@VMCpA$t4DUiz9iJc@h? zw*gitss8Po`rf>2Sq^$g57Z!&FPsM~?-=Dby=)uo>AG*V+}75?%M&9Aa?65yx$g6`g$15m zOX+@l4OTB)B&B%l=p`gu2MyT4>8O3`f`z{?jgPLczJCs}VYgYa0j(DjYp!?=nOZKA zjjtv$r)FH8ExfDnf)&kW)mhlJW~oDdE{nGnKj8TODbvxO zpw-1LQcY;;hshcaeJJN;Gcs@!@vMFMNR3wzccO_dqc$W}!R!0yKilK=tr?BI0N zzEWp!#A`op9)yM!hkx^1(DN+a)Zgv-CgLj6j|6=U;uOh&5wD)LjwWzA&JL<8C2(Bd z^{s`@FZ7aGqqv^YM6rRF%pY|QC2z#UW>-z1zGo3FWeZ|XId`hr<+9YpAhrVHO9EmB zAn?rhu?yu8h)hBlWEqT`gz!00W#xSt@rfSDuwqNUASnz@yFnB= zLeznQBgE;2DlDBEVzZEh>kS+sPDkx1#jw!&R^|oexIwwoE|5=Hku;}Y&S%$LJ`uFt z{_yB)rJrjDZKc1wuJ3<@6ndsHpe*zNG1O%R&C*)8J-3m->61_R1|E3DyFRdk(@{H0 z(d#|l<&MzxRc@Kt+3(9bqH<`P@*Wn8$demCd8tM(4|f^rq5=hRS?CXZKB#~=9b$Yw zP^3dW=uO@}_O7wej>!km92ZwRyBe89t8~riOJ!~ zf(nS!A;#weMLN_&pjq7kd5lh=opVzCloNxA0}b5D4BtDj8g&#v;M9Q6`J{ZHY51qe z2cq3ZAPT3WM1c>)>8Ks01kQ=9oFpU=ToX(~77F%P|3V;r1VTY#a(J?!0^)Rt@%ccJ z4)qY|l2WFCu?Xabf4!Qxwfy9s(n zkcm$B<1HG7wuvTjI?fKND<#nR^Rs(G4_L3-X8(b`qRAOfO*eeaA3*+VHg=$D0`=XA zTAL||V9tT=X2?jk0w_~#emiL$RrL_)+k95C+){$?bo!jQi0d>zL*(qaNMf zu{3f5y%|z7Epki0|8?}Va2^f+Iug%9KO%qbh$P1%=z*RGLGR42r06oER+2a!X9v}l zqIb9Gi7!I*Ca|v~31+YSz@(f#Rij7UiOTGky{vO5Tw1Rq$#C?->+Os;I(iK*hUP51 zWq6zY{Vn&q5rJ3f3v&Cf@ja!``$3)D)IVzPF*Gc-_joI-fB&6HL;c!Oe~rg<&swX~ z%GDRvLMl1j`t@s4>SM5>(U zR`W8%g?Dfs(Vspoe3J>e!9f~2myiA$b*-3FpQxjPUbgV49$dTGuGRCa=JAg;1!kC) zNs0bgWj1wG&8Qv9sec97kcrX%i%Z}W_!r}VMz_rC+LKo&w<1359F;xkoI4R+&MeTi zb3fvRRlesFT!s)-#p*Gav_@F5;^y1jJLJA*9{-D}m{SR#qEyA`#iY~%%rm9_M}3c~ zAbYw}Kf#~;N@kK{Ku$fbJR_TL z5dOeWEjWigZea`Jh7=vxyalKhgj$J9;q`W+qtj@p?|2lP*djc+6{%@IrfTS%>+zI! zZT9&3Xr(@}1qmyKJFSP=yrR>Z-fIu8H3;FFgOIWh4InxQRedFYdH! z68aR+By53N53Q#Ofgg+?Ad85$przP-VEh0Xk)7OAsq`$)4{T?LkPf1)Y$GrPR3oAeF_Ubo$Sc+(Yp5O%@E#KTyCJyfsgL}H z4;4T%uu<9e?67{IT7@(2D*OO96i565rwc1QcUo_HQCisIqlFKJy8Wu|h#6a(wA|O( z^X3=d$T9Snzl3b5m*IY3rtRhSZGz)*yK&X}0XRSL!e-z5SK?HY&GZ(&{IF5^ne?M@!s3*Q){XpQhyD|lU7t**y18T(8706(5qWohpq8H2kbmoQF@c?dK2##9Ie9$>RsE)?zubKP+(|X+hhVugn>~5E$DcR|Ay#9j2%2i<(4WG*5E@Tpd$C zq&Y9N?MVAYu`d6(OrJ^ix-;{aC;jD*)-!haNjxOapngDDP2JC?d7=NY^?`?sA0Wqz z?!Qm5b71@cIotc+$-dS7xp|>b=9iT$A)0APu?u1KlHSMnzwQI~{quUMZ+F)?dh)vF zPL||C!XKP;`2nbvxD<^B^l_r2!}|fB2_xLmO8pgnK>9#a>|z-|pmTb0r(H96|6I|w zVAKzUrqF(X@O0bw#VlbJ>GR`LXVrdyUl7y%-NyIr&V+nZLj}a?5aaWKA|2`(YCD%25UT>M zG`m{Dilo`antb%=3Y!8KT$VI1xaG`iFD?D$nCR9!O=zh`3vP0$6yHB$Zv8M4P6%wh z$LT0?I6HFDI^5Gz^tRD~%>r|IHuE7<9>ztEEH{BX89PJ$D=zp-=%N4x!GSX&pARY^ zPKOwu4;1N84_a4-T;6STw3-b5@oiF@WY?evZXw6szV1mMMK6yTBc;&#U)s~FWzJVd z?CIUiE^)s2S$XI6J>eu%l12mibobWlw}0Z1>%;Ep#pyUZs803KMlKo?)p^f2;)|w7 zw;i1)63JWNn(cb$OANKVu`mC^Da4k?d$#8&s-?YJxs{oR3%k(u**(37lU%+R>#&d< zRrhpr)n2V=YGs%Xitfh3wD$C#V=Dj+Ck_pO-rbw?uF63#L-+K4u9x%RGM~3DvkH4I zE?#tTN%|jbWwqV*hXUmJ|9#-oDMNQ zA1KnH9B_drwpd`~2|JQA&p!S`sFa z+ocFJ-O`C0vWW-;($Ib)^eb^XN)*_^>8Ks01Xft&UrtCM+-Z3|xNhBAy~9YW|5{#9 zO`th+%dOwhE+H}Rf<282b9GhaE5Y&8>fMedOEO!(^30M`HQ{nvQfw%JZk_P(4vds zqcVg)C`il=&lOZaoDMNQA1KnH9{zqe*?8Yr{Ba&I&-`y!oMN^)&wt-OerBhx|4>H( z9==Ksj*vibOzSRuah`l9oILuy%30L} z>bt2L3KEmUlLZwJr$da-2a0s4hrrg>1Fm}?-3Tj%X0hi9{TE-F=r=!#emF_%IYmBN1gwY$i3;;yobhJ+ic5pgs zM=5~|-aRTSBoGE?!`^nPoHsI*4ElC+uxbL+GYW(XFsBIpUwq2YR6eeUK)blw#(%lf zPi?jui9X{TmtMa8DI)d}GXc}#k=JV}^i0D)S=~=qnM1pWfD%qeof+7{>8Ks0=vBIW zU9`6ip0f(QKf8Y{|5c41^>QcXPZt#^2y&qLpaSA_i0Rsc6mh5ry{%uO#v04{S+TXW zS)aAfp_&QBoFaEwCwGZ^6i(^P@UKPnmh+_eGw5^8#f^o=xQAUgffQ!ql$*%LxkfFM zU*{yDIu|$m>wR;x&o%Fltbl`_fUKm)v(Gih={P&6u9Ux&Yq6py`h>8L8xL9K*YKC+ zGBR`BHj(M#4>@J=%&F06(t57BKU)FFFAjB1tvH#B>EX}yc)}++{2^-(+=@C*=gLm~ za4Ff-or()P7o$^eVyeJqvT5`Ei1k_f!Y#KuZJusf?)64Wr#qiCgn7+0=BL~wUu$KW zg;C@NaXm+zj=D8)gE$?vqZGphp-u~g7YV#~112F?ckVw?HHOr)MVLQbY@i^>f#!n> zh|?jaYY$Syp&krvZ7P0{gCV-kkXBq+fi%}4#=O2(_{xEMPOH0Y9+SCz-CER_VGKB^ z<^JbVj?gp)ltmzPI8j1i42aWF(!dT*N9`yju&=i3OCfQLkNU|gcq!E zHzrg-oDMMq5V*6tcWGl0$URuAc<0O~DjzD-F3j$B*>VLYxYEa0?pULiCiK!h{gU$F z$oP`q7L#zz0D3qbolXJta5`#7DSC?^g@~SM2Sj9TKicxyy$~`qHgua&(1Qv}no~PMff+c~~7?W5C(T!WKpcdNxcCd9Y`{ z(5tbVEs4nYet8z`Ttg1~QF4xIv?$J*KiyM-+11INQm6n}5Qn<<#OV;z)30oDqVziz zXc_iigzsJar!+|-o#%xg{@i%tJ!V%Y(PZEWW20pUEr^6#CXQ`?Tso?AaqP2-RHFsn z2t^CL8cs*i!r76F*6>ve3kcD2UT8h;Tkt^+tt_=3)=`ZX{j3W5TyVcubd35B3gQI% z1D`L$(fa7w;FJQi04WGz1_j~}{uUlkW;4$QR9x7?)XWLjVSKzR(|^y7-fR&UoukvZ zrR8JjFVCy*rv}l0yT07WAr+00_EC-4Z4i(T*w7?EdN9`-^FedNMtQB4uFqaPt z)~_#kURI4>5w=ByV=$1QAc!*||7!^q5T`?o&j*ThsK={ajTkHIA;@XXj-ctnir{8T ztk_I89nUoR>C?H4OUO{G7x4wN(H$RV(V$w&$Ldo2ndVAl@i)kF(XdJ5w-V3VmygtV z1(9%8_PDHm`m6|EN8joOc5pgsUnzgtauz zw%#*y@uU|=rtYM_yhM}J#)O{gxe`DIeM1ePhtttFYJeS_j@nU*-YPe1b1C%T1vLNl zKlIip=s^X9S2F+E0O%cUecbqSCD9t2DH9${aR}{k=IO)0)hp;D+!TG%QwlxP8l5b! zXZd>ie|c|gB~UZ~C7g~T26k{dYDX!0w~zEaC`2!7QlTZ=)@&x=%HL6^vHEup>+^b0 z5RVh}iAM@5AWnxEpAQu2P>^qT#0!raI$|I9#_n|Z3pcAwTX<`|=k={bqUg!R8V%?hMNh6teHOUq z*=ir^Y$I?w&JL<8B`~yCWHupzxz5z|J=JO(@z20Z=8rmul27AuH&pHXs8w>@W|e$w zK@2(EzN9!Np1NgX6bl9AauDchH&Antp z%hJ@BMVnO|En_02Ff>iSC~}0T0|Q5h)6uuRfg{A}s2!ykzWY@oQix$T))B%>*goCL zr+!gE-)0pkNO;u>9U)XeoDMMqVA$}#Icgq!ZII!g6?+^uLo9EOf7E4j>xiej-(I#_ z=SJzw^vjdzJe{TZGflt9;tx1Or%hlCh||%ICD_5~s2!#J&5E{eC*%)iMIH@nlljr6 z`DFIJ6?{~?!2*Dbpo0k#6a;Z5H(`{c2fzv08o~^6V zfE}EU+EI$$7XO$yA$pNbYX=1;M-!Dp+m!dPSVU$DJat?(dU?6aP!|;_h|5BM;PXKR z#OV;@^MN8A>Orq#ktn0NK5h&+V#lvi)juz5w==SFdEdx(6{(|uF<_x7ow}L`R6PL- zq@kTdm(=H~AL|-J;B=HIu!GZ4J4y+3-1@$_kiZwi?6ZBD8BIXnZ^`(vDXIz7cegAQ zBqoO^3o0N^hZvs^6zNb8fu48G!;IzpI0D}_n%ruqwyf*^ttZU7emhO?(*y$TJU&X^ zt6&=bDe{46w-JcK=_pa)193WPM=605ho2G6gMw>AwDxBBNrP&ci!r;uG=;F?~uktv8^Pl3*<&hR&Z&zf(2LJon*dIPt`6Q?r= z#QbmH@1zg)N!Y@ot)Hcc7bAPWT;F1M{lE`i*F!JUUprOdx#aNApl|y4aLK!axzlXi z5}@hLfB#!=0w2Td$0IL^-i?=HH)v*_{JjF#ku{JvKE*Tp^vH&y->(!qlGPg^Z+rs1 zKKjO|0|%Sxyku_fkUmtrD!yuUltu5{!JgQ&CU)MGD$re=#xaH z{@=X`T>3y$?3V6XT4kr>R-My}JMEes8^&}IwgCF3kLuRG7shGg$npb&T2(3$-}LPB zUEZpDVp-UxO?b96ZF9f>$V9x34ppSWG~fK^ zcF{lKVt|{AzuT=5gNNpxM1T3~IqzdqU9dmt2TX7N``_{dE!a8GE~5Ttirwa4I}Sv~ zuO(h0e&F*IX4T>_;s-vl`XR&*fF6hX0n4gmNZ}7oy59H%wGx-2(SYtIIy$@`XtSew z8?;h?g&&YU&=fn%BKu3t3y2}m(~CRpn$o*FtQWQb>IY6cy&An@@KmD28n@*h$=XAw zX8c;I+7D2J6Xs9%cN+?V9JqYqbcpHNgA{S7XGDIwNOCzj;{oJ%-yj)$^<7@sBkHW|);p ziT+q+_K(!`X6!2r3b3KzBEVfKx;+!R*TUYA{9)(+*qi^{7(YM`5xpBP#cn_22S^{} z&40O=)oU_~X#Zr2T~1cdhP?R?^c?7$|H6+yekc6FNtYjhT8T?ZokV79HCS|Xcs~%n zb5s_zQh$XXkUr29yBdri&^f)h)2>-CctcHL3!r|$y)Eqr$X@J=_ZHTuY@^x_2yO|s z6QD_d#P|Vj+>qgK{+o5FxSF*|o&G=TCpcYrplQDO&$H;#!w)xCJx&*+!=yWC6?n=wp{)Q4*)4k7L5w;YYctrRsT* z#odq9?g&xS=6d=1U5lXvyd5krId-XPwDfhcpdjIuDBN=j6%eOG4Cgo@9YQ@_tY1C) z8SOFkToVD5R*bR1E>)5BxnoVEd()E7paeadnTBg+wS?m3!+0~Ax$n)kw_e0)= zbd6o@!09+UsIGLiqe8-%kwWygu&W)h?AyVnt_dHe8ogqvSCZP*jtqZ2nUkhypq$YS zZdC)P1NBsx=4yx4xDmy(UNmbS(C*9nAv0T^roS9ktl3p5^q{|wdNtGQ$#$@fPCw`Z zmgrIM1zTruI{M%Wu!GZ4J4(^pSIT^q5ItDxhlf*tJ~3>IYV`EoX#oYXjm8GNH-id@ z(;>#^14TO2lGmp=4W)Eg>c4%V)oLjM zO`F|hIX@r`?I%LN5~rg?fgPNV+EGg2O|SkfgapDKGPBqR_V6FloI+pT|wswPn1c2g)wOb$;LR6v{#F+LwC(xDy# zdmsH`{OzW{%J{ggt`*mOjW0RDKB8nP>L`G~H!lY7mLkxg6EM=v25MT(tTvtdo|Y+z zi_=kR#=xBVM9tW$CJ;t%=yR=sD4dS=DZvg-N9`yj@JH3grG*5-;0)dl)-hzoZPf&( zXA}q(pwEfUf8tZ7lgtTv2z>e~-*{vBKyL2y^Nv3IqTGf#M9$Cg>20er(R9U!mi{XF zet6UHPgeI69#MgI4*?~djyf~2gVRwvO3}M8r&Derdhi4a=>4@STlS`E^oj@&;6Ab+ zpdhi%BLx)@r$da-2a0s42fcvei^>=aJ#P57;;y^dZMP_wS$>&&*xmM}?>1zHe;WeF z4wG_yrYAnh;!n#y@o5n9dNR;2Bd;f`!#?o|r{nCPx>EiM-i?_nQdkmeJgZkpZPweNe|wqc#S<+HAQ zW(4(Ry7NgxnEHA$H#4GPyul|#Q1!mNQZjd;N1m%|1p*udeum$ z71KLAEPC>vXdU8sgvS*r0!?E;Sp-6d6D0)3fH)l`4ea1_)Q(aD^Y;jTCUk@_1_S`U z{4-Vk{ug}&LP273c(R}Z;&h1d`9P5l^$>Vq)6xFMB9I#cdN}7RI52pQb42qdUq3Eb zMBksNNu0E|g9*KKPrsnA4+HdYIy#*K=;3tKj#Bh~H*iUkLJ!^!*7o{+s|;~|X`u%d zz#%2AqpBYC8jX8!#^~tT-H+bm{%-L?{DDw@k+11INQmBCNIQY+Lom$AL2dzkl3qC5);xu)DiJ zv03Zc0d`}zV(Y^v|9kG8bNAlaJIn3@Z}I=_{l49~b7tnunfT3_zJsH(WKh#;|0T3E z@?;pk$Cm#rcZnV#@{CFVXrVTuXCzUpvFJ3kSbR){)`uOVw#lJ2ae9@kT=K)x=gAfv z-@DXeXr+|OL~5-h3PvOmgcrTP1cz3kq8#f1DKpj~ek>^@23pSk0udTG+-Ux3YQfGWa~wQ*E00O@xU93qpy$ zQxNI&U1!LLMW^|gJ67{g8hBd{J;#ib?|OaOA$_CeM?hHr1c4q#B(JG*=q32wg#CPq z1X&Au(nRIszqZ$JVc7SDafGxYM!4Y`4vRW2QAn_mrq@w#GHwo;CNBZt&EpezQo zNgwW@??%Imwpjhn0Fi^#e?*2fU9vm5)NL7^?}xxIem1L|>$d(&AdkR%)Hhm?zD;q) znB&%+U0%7xv0YjgoyCWyn~T8V=dV7IBXHK}<_`{?+og3PpGX-vVbW)d5eO5NtQEUC zBqFhFq@pH8%WoS_=x?-~EYz*MDF|e(%(3WVg2ew=SL_zG`0llE=MNNYZshV!=G&oXcGPqPxROg$ABz4-LXVIEIQ4{T>Opf`0A$| ze>gP5Po%sWGu!eNb7AYNP}L0af)OckqxXjbDBaPf_lFd9(+K{0j*bYn7XGC5y6~=h zW)9n)%xyuZS1$*b^~)usBJgxqRp{BqfF?l?Ax5jLw6`+0_$%oygKxATo&FXJ@?p_w z{^mk&ck6d|<efAO_455M%NnV5(y+0H{>5ewNKcuLe zMxb}QL&}HNf}S)6-2CWa(8(#a>uq^H{`kcj8B;+ja12=KTp86}(>4T}gg`_T-8n4l zm($_km7NCPXhAxSDCEPU)BMdvpzi6xFLDINtlHCX^VRLrH(E|#_AO#D0*xIR!ibc} z(IYFtJD-hCr=D(g1g<@lI&8&>FSTZP{G(~DIVh}yA_9wy@g1Pn{j?4LOhO>)F1p)@ zh+@%cL?Is*o#taM0(%~rqL>Fo)r8ZKF5+;Qb<>Cr99lZh zNNXWb8vfl38Svab)mQCw-)T)F7Pb{`A`^#yCw~OyR>Pl71Db?C9JaA=!=lrg4*9U? zG#_*E=f7g^B)JB}Q5hrNnrZ}pCth{stc5?R51Orhu|l_( zb*w$BSJ|~wQh#Uz@}mZf)Ou`ELtwm4z{Ii+VesJ&GO110C1Ps^^_wY_1tZY|M0!Ge zqh+zU5~%B=xZ9fJkZwoaB0X^Er_P&>?b5O6EIu^dTm&u%SQjiuVAqlxl4m}@OE-*s zqs6yem2nm$5Kiu~)*(8J5ot*g7!-Aaf1@R9g%qDmK_Io>AnkKu(ZvLb|FPa$=G8xN zV9#McYtJ6stCnj9-xETx(+6t1sX;GZ@8)mNwAhCU^(U~F0ROW)ndR99bwxU_j;cP| zb|uPKcX=bbl+pViKh})B33I+4&oF`Ki14 zUx}NAbfp#TSCj_nrKr34k?um@&A)U1#Mbf#CQf%UtH;7|NI#`W9s5q^?mbon(n9?f zcQUIdG)i-0;KWMh8tpPDURJSlZ`XT=$a8?clezN2;P)OykLX@*U$JI-n65^to!-+e z)&o!h#Ya-TNZ?3BT8SXM#HQNOx9R?v-)ITQljFK6dVt#RNH2s*dI1;AP((0e{YJ~j zd2V(C&OB(mfA6zbg}Qt87Xr7ho~x9#^?>agE&pHNXemkNK)WdVpHZ5$;XQMuKfgiy zgVF;j$g0I@N)I6Y6r~4{{x_`$LQjnuEpKq*qzBYv;Ri27+OCS!vGqWn#mg#o?&8ToU**L@>w&w&S3ONzb(Xef(Ql1^CZBV7{^9p)EY<_Y zj+$UZ@@7-MGf+vVZSkN7QtrBu$_za~xBpDLT+~=MoK>9-yHA#m2P%qsK0HE)lQHrJCr)|*rBcSiaY*l~NF7@b zBp-MnfEMbv7!Rl?G)j|S)B^^^%PMy6%)hG($#a0#19l?>J)mntzR{v7?-FdW9*~`j z(ufsF|Ig3^Vdx{lztM8y)PQyt=mCTNKRsT+1b`Xqk;9ZJF5f%UZb`2qeV(7)?ToejG3VYw;<0wYww*bW^k{g;TH8uLt5YCTtq+3eYmR)msRlhy+vky}&*XV5J$MH` zlQ)|bx$t=;++jms`-1xcSakY27#5#ovifE0^GGdEUMnSs*5^5H(@%O%mOhV^$G=-1 zi=ky~bb}Ge<&<~x68!T>M{8E9Xmw}}^YZOqsl>#_;}_pP<~(Khbs;z21!Q`r2CaD2 zYXAQWjZdl1BjG~hDC+Y_xX{R=v-r?-bG6#EezP~pq31;w8uydWBX!B_yxd~w<>YIU zr3;M-{&}R9Y5H_A1$wLnMHXG&mc+Wyc);W5ySo*RGziJH(Rp6>`=1k^xYQ7hefCPmIXp@$txyd2jt-EGUY zp0P{OFd}(Pm1{i|KuP4wocedF)en98u@Mx*Ip=+{|?a=(x+q z?ds5yY6!ILGc{>Qhe)IQiP*1X(P=~>9~PbFV=e;E>@HM5jzHZ0iMIlNzW#l<#mdjv z)$|w?r78dLyEd-WJq^8=lH&+C_fyknQF=fVGZf>5>GC5()(A)o_lDc znae*87&5HJQ=p6cOk=_ytyROHO#_;QKg1c08`d}t>9nRpJ}f%T-(39tob$1(9DjHK z0u|7(;+=*i2>vi4d3F6yHDKW{ff=lYKS=}jIW}VC)TzBa0+O$K8oaFMG{_Cqfc=Lp z3bi57;z>=^TrA|U==42m$cIIz`Iw8q!z=o^$`Oc)3BOKM?EZpL79%jD1TRC4g%L?! zgcrR(6hP^YHoZTjsGCMKUZv=V$tb7C5{4FbefO32uyx2YK|O%I5@+v z6NPmu-rHgX#$^3-cxQ)rR(2bc|c&H^C^Ik|2$HMVwI<=!O%7fV-gHeeX)9uEIO^$kPnMa^D!5O z_c9b#%!1-&pg0Nn@!yd-EQVoLsY)8EEsRL=BE0DRp#VyEwCVjJMcp)_1{c*Fy22C~ znmYT5{^WwNWlt>T+Vnp%^E1w5N0hI1&iw6Wwt6TiM zwGb$c0jJzw{PE1+XBus8yZhkhJ1b&@^zCiXzOD^=7Egd8Wa!TqA@o>udO8L9u;?@& zbD@{w;zS=c=;7Ci*5~fM%_`7C0T66TGajIqVPPt7t3$8rY`-U+y|UK}ah)?UUxwK~ zg;ZX-I=qG&^#03TongxSrfsq1zu}1xk%L4JAoc|Kh6`EEGx!V=Sa49|O z?*SG-D}K)^l$-NlX1=y1JjUwoUhMI2u`WWXr5f}$pS7W-k=Gx?_gJCD2rq>T5P2rV z=aEnw(KC{$)mU^IS}Z=MLTg^+cE$bJvx*F;bgN{T^m(Kli!Vo63@zc#OCb-X)=DZR zj7TC-{t_Ho^YWLdX9lzoQfT4~3fj?(ktZnD&m--uf8G9A$RCZ?wW)M+Z<M^l#J#YvjYC(|pYBFg7Uv@rPWi;avXO3*Q@$yt6>( z+&$d#6?0(@T!fTCD~A!uYpQ&#h5{(v(I&NyNMM*oW=k$UaQ%jq(FsTr}u*tNte&{wyA_;a;zt)52?%wx6XV8P4@=f3w~|{^|l2ojz`d zd{}gvkGc4poVvgTIsWE8D)DY;g`L`Re^mY2ee5hbp;pK$YL@6V803rFBlOfl=g=LpgWqhKcuUhM(~$&^xv7Sg}=f? zT9@W&J)U>JKc>zOpQne0?g(E2^c0J^7!id0qFvbA<&icRTC4^UKD3%b7_#WJx9wUcas7?Bn#9zPlL-(Qz~WkmU^rf5TI z$Cxzl$)bx168~AJ*d-WtS^IaRpHH{e2^_u6W7*xu?hq_R4A)8Ol&meT&o#taM3~LVFt&zhJl@xxq;X%Q*r7VV_u`7}=B6+Qq&yAu0 zN_VvBwI)*3O(UJsWtOW0m?teJZ$rMG1do)cox}i@->S89&X@UfgFELH5GbFWsW9+C z6*U;z6ro8lM7YuLsc*mCw^#09gHH$|omP0rhefCPn+wC>qkk!eg<1N)pI{ffOZtSM z1-lf}x}cH>H12{7#DrZtGGsZ(SzSL~&Ti#dPKP`Ozc= z7LKqX(Bg?1RA4ORu;}#Xa*+>G!6MF-O*;GE1D~4h1I?wFCp-T$GG~LlJ~B&^s9HXkELtB2Dz~-TH(;F*=h*1 zbwy3mfjEexzwwTUV$tcYCGug>X+Gv6u*{xwb>#@eF&citefhRy>nuiKTn2+E0AfjL z#sdOBeHeGiS~^ggld-dR^KSgqzRB3y*I&%wKHd=!DDR4H_F7-r21AP#;dXIq)S%0W zu%f$=NT(GW@?p_wKIX!(-=!PRuv=Cq@pBg>daKrTkhhZ!$6dE$UO|MWK63dR+ zBnB|tX}V;0a;e)gI^Pcsgo8MR83p*%gvBt7jH%kX;+n|C1J3XuefLHA zhcP(rKrh!tF=;}yEINx1O*a>Y%iBJ-m&0&fuIHLQSwggVdtc7@sAZ7OE-3POoM1?b z5Q{8K%m$9zKq3gUPJcB7+J=QDArSkQFPauw&UKrn zgRF%IhlMOUJPt-ZN)LICX`lEZ#cAWa`?)th5&TOxbd>xjlUm^oL>Ow;xUTdt0tyW!=FtJnuI^>K+@AGsMc6?dL07!u;?@&bMZGf$JrBd z{9*qPmj_}d7xS@L4dTrv@(w2A10zDaXzFo=0w~?lruT;wb<+s`JonB@YAyUpYVcK? z`337WIO~2mq~q(7(@X7xR48_=U9X>My$yyIPs=(~QE zgc(EoLjlkoP1+yQ)lDNX{8;$$Ia6S0>M26>Cl`cunoxpat@HtnYWSV5yL4mU-Ja8z zSAf6@82V)${?GkZ0MA z)7C7|0cUuSo_?q2(q2#I>jWbIhsP*bbQT|)ZY~Tr@6VvPhY*iZG$`Hb!=;+DbydD~ z9c(cSjeQI-wqq2Xhya*DN;9^iN8d)Y;omQ(o-zf7)M7;Z9;0ZOV(2g3*$(d8q62f+ zSQPvdcfEBp#tzvwCtPA)dsXnUam#B`=*M?%WWOJ?P+G` zOoQRWu;r79e)T&mL_75#6&Bg;p5yqFAF88+(jHq`NN~g8#FXd(BEiV*O}Hc@PgNxK zx!cWOicf}A)g&JRb|9uKR+glaB$8htXUIiopLhGEymzj%c5^|yDV{BRXkX>Ee>tQ{ zUo9+RRuo$#MRw=RxTABkv{y5R{o)+P+vSgH=r}Ap2=fAK{ybQ6c=#A8I6Gfffko&w!Z-)Vn2^$gO1lptqeLjU(*j(^Um(0`>^=QFsM-aqG9In`Xb z&W9Wf6uBvKkTvXYM*KQJ4x&`bSoHMniqvr&gz1`jXq^R5+;m*i0VRS0uZ024C3*Id zv`}A3MDqH^D%K;!ucBDvTKBN7p^0@4P2i6ipiF3#rb_MNnHrZ5HYi?Jv2!DvL{^dK zK)Hwc#>(yO-+$_LxZ@&SyCvf%_1&~ach%+gA&Yf_IOPR-W?0e7h!JVQRsZPG*^3CE zcay&v@{_yj-;L;mpM_5qHbp1kN*FOEoxq~&Bj>oOV><~~sK|2|?pw)6Jh^Otn{285 zyFhJV^x2+{bw3pYx}X#It;~Lzk9D-RI?yPae}3bIs2<4v0%kD;hzT@sr|Gm^2nOw? zv~|R$4tVs03Hc)Xvs4{u$VrMJiY{rC#zj;I+R2-W4$dArOHv0p$+b0+imq*x2I&uy ztt%I~8oRuD`u+Vm4!g?e+^2MQiX#(oQU@5jG8TS;nn*iTkvg_Ih7dVDG z&|r|tL;$oaO+$W4ceEK%2Q!Zr8fSqzkoGZA>Oi7n)L_QCfg;!QaL4(@YH6n(STx(! zy|_OFLUoYi$h70uRtNvt=l~Lqk4+t5P7pKx)WIF`9v0o%9r789D9!ugOD?Pp-=a%T zsRO(F!u>2dS4tfqy&Re%XF#=BY%XrX=! zb)cTmD9yW!xfb4^8*EU#tYYVC*!ixK=K!q^ik2+6aa3iU?pq;I9mF^}oV8dT7`uqL zh!~MpS@ZSHe1fZkc2k=-GD982Ix0Z*AWzWjfWPyCU7q8L(ZPXxE;lM1xn6J4Vb`iH zL+a^gjQG((#H(Q~)YJj?m+8r(d}Np!&CgEYcOzMoMH`^W<)7FlizMwVdZ+*O#YMY_ zc9y$D4^Z=`PzM$-o#2Ln=6>>d4*h;Q7X1J<(|~+fbefO3bG9kYWN#_2AGpn}S7h}P zFB{I+)yrDI(P9J|JKup3DT_`j8V&_ex}#0+4=L)Vkq+7L12eCifk3Ilg-BzWazSG4 zkWDM{W>bk5HQfTIgk-q=bNv?xj2*I)!{@%XAu!Geq>+P*lq`CFYH)`LWYK9p<|1(U z{qgzL5O`@!o=Wy<7U;5nZXIed09qSJiL zMc{+bcT436#54G)g3h;l{N7>&8avg25$RC{Z+c{*07`eX>HQ%^-87;De`X7vX)Odw zyLdLA%oljP@XQ8(ozkwGJ^Y{hkP5}RrDo>?Z#5X&x}qk*5aC9{2XD7w(P@Q;d{}gv zkGU|++-FY;ISlbK8q`A(Rp(Vs5Ex=aO8DsEg#swu(Wdu@6m`=G3?1Ir|7tB5<|ER& zbZh(X=iYO|J@-ycmg!K(e8Yi`hpVn-uT{y0K#RMgsK8jrVbP~3ror?Il|`rdn2W$N z`P)yIBM|jdrMz4n*E0)r$*)hYWibMU6*r->86pNFB6X1%dVeT@(j9Gje@Ia`jUdoB zPeDhkBhazk>kOVRgKEvrU2N+bueOIF6^OvnMc;*wjPf*>+k zbh>Mad{}gvkGTjO+sr$?9Dz7Si_vz-dtz#kZt1LbsVzoeTn2+E0A`%hj0XfpY-<){ zbp)ncJamLh@o9AfQ%&=`J2drLNF`3kTsW}TK@EYn!JtXKP&^Su_Yx6NEIO^zkPnMa z^D!5J=X*VimLm`kJYgrWX_40DEJmQPHCljp6@$SRP3#_79fsoiMYyzymDuBb*HXe=coRb@ zLcH*%7qwo27v8YwEIu^dTo@jCmus3FhIrwP%g2eO_oQ8-+uN#PjX1%ODzY$yNo*J1 zNbMz;)+bnWxuCILc+(|kDP4^!|1@4{cW`l?s?&MEk*=t) z<&s|>?BQ{Dh8hfQb24UWLsmbMMW?kJYC{&C=3_1lTl)GdMue!OaAq>e-vw4!3`1kf zgBX##*8Zncqgi!zUz!3#)-oWAE>BRb%Y#7+YBX|f-=@I|&#^sp9j>p0z&Ikjo^{h) z8v^4zA{Z=U(|pWD;DTP2+~tZ8M}!Mj4a>aZ{5;*} zx5b+#2m&!8FnDlj)m%ZamcdAATLG;lIDy{jp+?ZU8mQiS)G8LVUp<-gn8y{%Cbw&~hZCmN5P%sSiNVUO-Jb)xYo zp?{%HG$Q>geWG#BnV2>5b|y}HmQgBYEc{IdM5>O8)Uo$0Pb}GeIW5$0v1eI5p;4Nv zvlqQD_T8{}S;fvxspnTto&)rr<;U}H_IIqfQrC(cD4db~LLH0ML0SN}@EEom7sZIQ z!~-#;c7jXr6OGyG6l!dWI-rI=k~(0~AQ$_qH#BTIJr$39Sah1dxgD}2OP>8DN2K?3 z&zFAJgS9wA9$a?YU5gQDY*GRvl2=&yqy!3}bVr*ZqR~ZZ8W|G#wB%}8fIw+(kV2qD zmkYp}l#r(Am!F;VreV>f^}^DH>}q%IM{NkqPfARaKG$jY$MJq@FvNa}A9c@!?dZTR zQUJoXNrW3ccXv=!-C7o%h86N*(P=*B!tn9EEEnZ43@p@U{l@jdTAUkf?OG$J#V|Cs zR*ezKYpooHD1g!(ZSerZov+;LSqp~JxF~mqv?GHXde@t>{Y>iFaGHpJP!Z;7I3brB z0&R-WBt?iwqmlDa92yuXNTkyW5Bad@G=FmuIAG+YE^-9!INaI$!C<{2Jeq6Ki3C9) zMueCWO+B&_ToG1YTBC%u5GX0abc@=A_81mXXG%KPRF$e6+z+{+P=rl9{kPa)Xz>(1 zDlis&Saf=OB=TX=X+Gw{FkOR{igUfFpK#aWibHWY!J|JTsfQQB4kJRlXzKl;07`eX z>HQ%^-89l4^_r0Fg4JOd>X`i8dCvy*R|IBXS}(HcdPs!=hP_%kWl@8ntv_m#HpJl^ zy~2gCV$tdTCGug>X+Gw{a8;HRTjbghM{Brsv2v@<-7MCIaTyk(04#W^(`l*^82Y;n zi?9|9rT*yTQHT73eDZp1dg0Zt$+rgfAV2m;-8}9Ovmwx8Md&WBlo|9p5m9tM66v&J zLq04z&Bt5>M(593P>#SFU))MoOA#VX%q-jb^oPX=%pn27P;p^Ik{97c?=QjoquIKj zFlnWXH37q-%M-+!n2`|JVaDVFJDW#Eu9cM+z>O!*Uv|>X=$fDDH%!Q$Mg|W@$Fhu=?Gn1E^%xY;d46}*(%l|90 z7|0lruZzSai7{EJY|y%(NOcD>_N{m9;1P z+UGBne#l1%tbk#2N6k_-7}`dJW{n8xy^S~`WYOsn9`;jNbefO3FbvJ#{Jk88I3mQY zi}ppsE!T#|V2BaPYpoovD1g!(ZSerZ5~)%KSPOvojp?-G@hY;U?EdM- zJNJHG3&qV^^xnzm$+vJ3EmvtH$nD!(&ZNj@u{sdC7D792*nGbt5wV*21i$a~afy+Y ztga49jE%ncE;2=}@lV=anG@Kupj;gk&Yf?CnmX7=uF(}XZNWEA_y^GCP3Y0GP3P|3 zmD+6TmaSn(#&cbn-@0=>__v;18G+uD^WpmQZUeb)Tt7l7!#VT&<@~umoEJ~4#*HHM zvOK+x;C}%B-;Z}4Ah?d=xdK0D!5qMq<6NZ>9eKXae4KrRIO}k|`PjX=zPwLgKD6wpVy;OR&)LjY}pyY=~OOVR@TXo>Mlh@NH;~x!pQ-5q{%`Mm44+f9(nlk86 zn?2g>IbIK`nt!1Vy^E&ATuGK}mby#f0#XAnzQ~_L?~;G)@CWtmA|cA_*}7(%dpQkz z(`d@uh-&pq_)MA_J-8Xvv-!j?FqB6iPVVp zR9bZtB`>Qbco4mje_r|k@fH0M#&XYaS+XjIJR4;YaB+xQndo}M0v{9{+gr~d$-eqIB%toAJfAf_8_ zJ{hXiS%fh#ksfug5N{7&bGY!#8}RSyzW!S(lzVets$Se6K|A^Lb~PI0Ax=X4+2d-DP}kOVfnh>9!%Z@WVvVm0NEF<8g~g?HY0cX1}pzu zPiiU=F^)reYHHlG+v&X5-L9cJ7M;b1rbEr~ zoiku{%RPg%-?{c}ceNa`CrQP~;&(2iY1GLa|yuUS7vGII) z_?T4n{|MF9B?odNw@)r$@hBn}9|0*cgGJ7zVnkZr3;$T*KB9ic9YqO*Mzk?` zmjKDzsl`m`1Qv^q?7)omKIGkAIuox#MmZYOv9#z_UjS z1H$(*>GXyk*aAn&OigEpidIh&T_TD3H^hxF67-ca6QKQLq1IZ)~BSO1q z>Wd=5H~Oq;Z@0`81hUpKS#)`VVqM=Ho3+@e3;~7e%v?}?a>p(ug+rr?_02Z^(>^D- zB9x14_^vM#LpPvU>Mn%~5cx`W!5Tj>M7YtbAMT@HwF+Ie*Wd&e(rH*B9~PbFZ!Qd7 z-W0hn?{6^%-w1Tv?)T9b{Mb_<&*7WrgwgZ ziV*3v!b3hRI*m+o5qR-lzT|QQ))?$sbaE=aB0RWdRfz;aAV#Fbj2>ADt_WYx`=g_^ z5Lg%ycsuKZ%v-;GZMZ#b+4%r}>x* z!(+qdUXsHQ^%EX|n!c>WXp3QJ>02f7NP)H8I-27$dqn!n-Lfu zaUW`LEf`AuQRk0~_U*e?$!(wOk|V)+dQ1h`u|Hby!pxI41X`>JZ-`T)1`{xdD7qhs zbXu_?9~PbFV=e;c^c|wOz5d*`+#en<(Dz3_RC;as9~PbF zV=e;IjC`!PF&lw_QzC1wFMnsT4m9@t2#kn@Komgfjy63~k)m!I(Se!9jIjQl9DSOv zn6Q80<2oUIer`?u@>&f@g`z7u^j+NpYB02QMNNVsDmMCP26jbRbh>Mad{}gvkGU}1 z^zhO*wXP_hyx7yGXZ8evA@+Hd@X^By1yH)9P45pW>ZTDG_SxITq%}g;N(7587lgG! zA$3Kwmv|A;HqSthrQf-ku2a%ng}|r?a~|sZ#fCtOyP}93T2UbaS#(nFhli z%<{=ZznPM~DHG)LeKd2QjP2U&d*?c9Hy5;<;@Pr?_Elc{mqVKL)x!3HiZE-$Kl1F( znQ=$wW@)cx4Ex17jJL}l)zEQRcF68uqE{{>Y>a_$u-A?h7jXiERjUoR8wpk5t?S5D zPu#Q|F|Rg%(aK|QXDynacl!zFR?vj_28$~*y4H$|rTL>DIac5Ket3t@gSs}mskoM^ zdrMuL?MdkGsB5#4{+_-z`|^_DS#nJeIT%QiF3&+$_of-~>i{{3QYmB6(_1N0C+?u^ znt5oQ1y9^`T+;z1f&#CF0iU@=+m57#`l=!nt5}Z^zlvgoqE$Yo7b~C=>l&I^=g>m;lxYwX~S;fwc`{&d;c@EG=KVnjj``)+R8eMa8ZT7D{5o0Y@2kE42 zG0c%yVnkZWi}0ea_z8Y(c9Ez{J{G70Y10bd*V=V}cW zof`>(u|t-{^Li3%s{`9f!2hq4fM3Z@w#kY;qfwf2o}+VgsJl};k2(o>nM|;LQ0zU8 z(jYyGIthsM_w-4?@_tW$%G;edsRQ*`_={kOw1JA$vDHEL);agmLj4x%Ks}*Rn#W_? zj4G8gR7)2xtJt|_rSBe==K!q^k`8G(rNGd&+IQq6VEx0#msqS0jD1BR1&K)BddmAp z34RhV@7i=LEKmp1MMac4km&LR#X3IkacRrKU;Fyi37t~9(t5{_E9B~6en^p=YU;pt z5)e)Y!pXz`+mnC}j$Nwuc)8bh5>O+e$#xP@-l}k9Xs@8*nLCk~Un`jUgGI^%ZK9{R z|I2#$Ad~GRAdLLUtO5VVXAgf!#C8&p&kEZ~z~AvCU`*fF3t~M9*yhZH~mIg!|>YhhleNynv+3)bH|agYTdwi&qCH7ZCucx_sSrhUbsL$EIQ3co`pEmDVlAxx(|h& zhQ0P8GoZbMEDTEaW&<+|ZAXJNn_ane{Pm~FHHBnw5mn1!QO{T$EC!p#knl*t|(;eN;>Za8NVC;Q{UMvJEdpq-p;z{uX*`W*+I4hW*r$UWqOy zPyCPd-r`R8YG?7O_^ST;1)uZX4bLzEf+=>*G`)DRmKqG35hY6N)1-tR%`Z{miXrQh zwCBjWh67oBlu2#?9pa{+y+_X}@dZp_*{Y4!x$^AhA(39%uCB{>-M!UIyRy_4hvZlO z)aDLoGbh(GKW*a?-9OZMFhp2$8%x5=1-^6jhKJkBD;dL{ifeA4m%Jjqv>=mfiPZ6cBP3IVOWtOo!<6C7ZnI| z%6(M2col|@^oh@qY7@JLYH2!MUqF}v8FI$Ni!iK6vE`-f5?yIQn2OoHHjEcxSdn4{ zriG!A1Hw35`+QR_%$kUf&*XMRPtzl9iZV$HjHtcy?AiOfeF7u-@En)!=-+N?jZ3`u zG*Ro(-J4yc6VIa4&_O;dI?YGXO(JXRk)(U173{sVqTNsEY4&osU5lB8*$?+z-9E)H zx4r&%dgRIyHd@HS+OvbIFaf%4J4RIKH+e~h8OtlI^& zppF+8{Cm8)P!t>UdZ%I*#f?lav)P?J;J(CRxAXG?dus{|e=g1ttyUD-8AWl1h#@Zu z)?S6##IFOWS5`LQ_=rw!esYNfojuql({!T3g(&IHy;u}tr#{5Fm*NxQ3c%N!l08$k zB&TaHD%3nl|H=b<3EW(M?EhCSi?Tv{!asCvJq24T_(z^atlq>-;#b(tAqK;LsU{(T zn1(fz$RW6Y3>bFHd3AGb$L2pCot-pN=q*?T9~_L)K^l6)?hMkT{wipeva#=U@BXv<=BE1}#&r^BLSLNGFEpW3INZNnQWF+P%~smj=YY zvty-Q_K)XF{xO^n1s}{X$izYgdn!JS7pK7t3P@+*dm=cktqPI~Pty?~bo0&17-+sR zQI&T;4h*c`SKDvo(jlqm4A5>Jvgvx+sl%k&0g2vU<&Cqv&A9)eu$|nl07%A3kN3Lm z4XC%Y*t){Q4r|56w&sYP3IE~9Guz(J*}SGHbAz7PUg5=6(h!P_f(_~$RtI7lf=YCd z=mEr@02f(pT^TXypvQilk76?c$00o>wQN5z)w#2OjozN7g_E0dFy5IsMpvM0ff>wxUP>MmDKWa9wbaZ@J7J z^^U>CZ)(&l(J^W;Sr=JJw+GaHRyUvB#@X(hYI^xrT6Z`c0;Py?(9a@Qx)qpCO;5$^ z&;H&whhLliw~sv@7<0ACpdZT#yfo zPU{16VQA;-t+>SFWSIilk534dZnHW#{LwUvVVF(GQ20}3F;Flfc-KFAe+hnQ^4X6b zg-wAW!p>AvpBRo~?M0Db___Os{9_Jm)o#rbeW=tXZ!ZX}n0(4`cBE>L+6F_`IAIql z0O3+Ogd5%6aq9E(NSCmE2De!uorV?iVbN*+=ECsH{O(S2ZTR|h@vA>tg=+DqLXBuilq|;gt`LO6TJk5pS>%03a$zhn$ ztK94|h4tDn?dvTa5(I`AkrF<7cqOxlZjKFx7Q+y=7z;iuIz2mvd{}gvkGU{(OnOwdQW;?`#c47Wv`vfXrS`Ax?- zrlZ&15LPTY-N{5gEIQ4{To~p#G`_f88{&`+Zb050CxY zHSzUc(*Aqq!uQm?RYFYCIHOXx9K&zFe+`s zdJRHb?ipOF+aJP(5cW(v)j2KQje}rY=;VKe-68E?Bq?^FIGGbXEOBIXblQ8**G&vRA+`+oxO3HW*sm zDaB4Ey>A1@hAcWg)M(rYAz4VKpStrJ@w1EkUmAHG({ynzT>M-1RtJw0I=?gTP5;bY6C_szzy= z9If-?SEpUNTGVZG1;xD%x+m0aa|Hap z*W@`sUoW)b-k7t8=55e5A-BzqYyar8#X7;*ZF6(Ph_od4i6L!zjc}CbN^pg z&YdOOO=l~1cSmV*CHt_Z)A3!}CDfI3YsuQjKZ;%AQ5vNGpst)l`gi)uxk}TIu9P=E zancFuvG6mXMA|uu)UkC!kBl!{(n9?fIzc_5QJTbFRR$Obor9!k>>!d z6Sg#N-f>{?Ms4O|w+A=AGgz0tW9ohu>jYz0&TS_V$(vC5a6Q4VoQv|B5NLr;kS4Dw zogmTW35s>r?85CX^Z)EWqu$bSHBzM5mn5%&PPkVqVz8P{I4rFCil@Rja=Hs3=1u6) zvTm2VccnI)x@Bt^l5uU{3oYGd)vj8i5S(EwLHt54{_cJG{+ z59D7!q=Le6wtMG<41vZ8&KzPEft`9%X_07W2kqKV;to{!wGy7Er0OXz?1N?z+Nv7- zuPj%Js{mnn9!z&qW6a z-;#faN6DL)%S_%pdr4;C|Lan#{1D%^0w+rdYJ}(41tQ@eFkm`r8~=fO{Ogg>QjHhzK#{6 zK5WYa^+YkaJ-;b;LA8!dyq;G&>AGTQkGs{F6P{wl{vA*6YUh8jUvle!?oY+IjN_1= zoEiZ+{(9N0d+LKa7M;b1rklI&P$@F-ANlwq#qMR_FJwBX(~`rpZoLK%w|G1OjVLKX zvdKk1hm=f=NDCE@A4i1IMV;WMcXK~1vwdqBgOJdQH9hkA6 z-hJ=Wt;~iyIkej@oQ~YH*W&~PO0k%Wk?w%Jb>?P@1cxES%6?*72m%lA$G&$iWh z-R6gs%;7Y7i?9}=*bFngd{hw|3}2E=l}}cfbZijeMz50Z>YS>+rr`mD)4NEgVTF8H zbeg}pFwE_FzL^|`V~)6YxD~liI=wq@sOLP3VQB221V$vUwes1u1Yd0n1gZHRPQ>meT&orb5mFg)^g;bJ)q*R^hz!(rDxNgKv!ryWcX7-B@qqLqq< zOK@#yxAks-)wN-G?vTdKr;e+?H-AiyT%qZTLvARvq0VQ`YMVBUvo>VGhefAP>7q7d z(P=*B!tm4Wp;|c%QAy$9*-qaIR<#(0c%iOb%OUJABD9O99)>7@(j9Gje@Ia`jqK2N zA3JQ6)nRz*UhU|eIZrj7+B0N8x?OdOB)O=h9QpW=$+LFD;AyZWFj9H zo#taM3`@*?r}#D~4%zVVY?F5REuW%^%h(VFV8KhBPE(D*aJ%=z+*XI-W3MZ{vKNnN z81^;!_)WU?c(TPPD6D0n}dU`kH#m7mNeLgnW|8i#Yl4)0jKrlt8blJ2YRc+cZ&f1XG znPkyv?S|TrMW^|g3&S;e9Tmq0QAy!M z(x+>2Y{;V1V?E@JsA&w34@a%|!+X^HI3^5{kt(8yZpa4pDw8aAq z9VXoBZFLx)f3mvms3Mu`EU%erhPIFAV@RK(QyMmJ!8{ub;|xPuTOkZtbXw~n3|VxV zkGU}1ns)ISH5j5Yns;|?AFIF+1wh~_&3J&J&!5gwR)^t=tFy08-_h57@#CCVy7ivE z&;W+RqVjpG!7yG=?`p$VhL7+c&D_jpJH7jVb$a){xM-@YuQ=ZtrCH(l=lY6+cIzrp zr+4>>dmVK5sMEWlgnpkoy^Hh*^y%GgwFc~#H#TuPsfAK0W8pZY*Hfg9eNt=cDc{z# zP`|}VE%k&(Y0eg(wzhq_0|v#*Dt0c%wPSDPIY6J(x^(*R%@Lb7>l%{NyEET!U1_mS zz^&c#E*G}#2gHc9XctZW&dUTpz1w4PsW}$t1Zig_HA0f;@&v_tdUw*6)!rB9b!fb0 z(bfmw7p311ffZe|b9;IhwYE;Mo! zhh5XM8>g*Vpc89&lm_Ws@^$4RR~yn}=+nFHw`BB|H$HLF2^hOF7LG&uB1P)hIw3g3 zc^xg(Z=n;^6B?yy)NRn8dygK_(#6XvcCN?jzmmvvfYu3DD$V-C^~@G+DRO!@GJL4L z#X7;*jSkmIL}CTQe|`Ty!B6kLsnFW`pCxD!8nmqKX5YpEWv_P5(52iN$OnZ^NYbWm zYc-u7Sq&MI(09W zx=Y~#Xuje~4N`f3s}4MO@_PDY{G$PH>W}TLx#fEM!Qi3)j4b|k_5s`JU5%Jgw$r;< zVFWXo!X{d5r+0;X0C>UCRLmkJ+ypPS)4O68*-r18e)t$pZ8zujOD}GaaJPg%Z&#zi zNE44%K-Gg^lC&vOCrOg*cRam2?daQIv7X*tSt+oL+w0-A7S|dvb>*sLmH8x79hp)c zd#ZJ0;`N}!_9Ach6p3uWobVJIg5UA}^#*3-N8%eDr$i^x%b&CkLmJIx+a6M`wm6Cs6{v`laq z%0)JOm%7D*O#TG4yc7 zAFB>Zr+0nUwy9<@42>O>z=)JZt1pTKUxhC=YKBQ4c45JdMVBWiRv30$Hrugb*$-}0 zU$*J;dF-Cq5LlrNdk*c?!ln%^-VDQn)s>y&?+4vEWS}LHPHR2n!=lshG#7?fC+@r} zhv6!Rlb=fa>$Ty`=h{gL0z-^QUTftGqzSGKbz@#!vbr|(Ss1j^0^~uwv2aPA2kU(P=*B!Z7Bv=C&M$IAp`av$cb2ys#LCaTyz; z04#W^(`l*^7-~P2cD6bUM>O!BzoqD}1{2Qo_)>9Ws!)($(J8Iy64T2DLyKWpO`It; z=zJoq=*}e4Y3+u5Sah0?xiAc^ySBU>hNT;9KQz_ukTgYe<*z$V7Q--?gbG9Lg%L?! zgcrTP1n-oV^2xHy>M-1x>PENIOS-%7{+c=4?$={FK_)0*m||;_>In|RSQadP5~vUXlmU`Q=YNHe7@x|ksGKi1Q`Q(av0-P)ie zw01*2EIQ4{To{&aQKq(1lQzC<6JHbeo$BBKA5MMk^o?M6DK&6C#O zV+sseGomcIK5`QlEIcC`+^BUY(qr3$z3+c!Y9-u2tbpOYX&IZ?U}$lt6g!#p=~^5c zvgq_!5Bad@G#_(e`0`iZ<#HI}*booT4t%kDSAxJ0Ba+uzdCQ6dDBaN(4=`MiF4b(S z!|>3y3N631FWPu>qXwrA_IB1n`V^hgM%SwCv%xUVFr>8=!jMI$wI0HdMW^|g3&WvJ z8;w_kAu6LK4hN&H0z(u4fu}U%0fsN0d`N9|80K&schx&@iw0{4`E5S8>0oaI7~1E) z6{H5kcs;#a$vbj+XOsD>-zt!V6jfHml|@z zHoTn}kyi2|y!?l!cT0WTp4I}LAnmNAMo1D}o}gGy?D~5ZyXjiR?r#1@hh%GpmAVk3-9(+ilo}gIw7jE+K^>6Wdblv$mvyYl<|NOIoPAEU>{W3M3Z~=}D z@sA(JjpKxmCW>E`8bIjLCVYFh8u1IcfZyR2*BW@nJS{VE2U;?SjHlVYy$czkd<;80 zqPs*7Q2NIY$RU;Yr*?XGU`SN*^eqls{q*iPn0w$Ks0P9hTFv`}D6ePhnr-goH0({I zDQ_dH)i2>QX=?P~X7G*Y^~5jKpZPLosd!O3sn4w>!py?S2Ko1ivrEheQ_)Z^n);Us7i)c z`KSSl=pGfeVbG~o0s`K+j$HM`O^eG9^wu<#Zvu5l zIJ0;dSnI4RH{ZIt)NL7^?+3=iVTM5_I)9olJ!Xu)QbFbwQ^`EmR~J7J;T=-)FSv^! zkPs*P5Nrv zPETL3=^9_{_cZfbJXtY7s$Gz2gUj#UB+s<#{-Md`cK-k_i6hAvmp?YITKRBijK|En z_CMM#{xMph7xgHm`jy>EBA?ZZ6|>ZeEPUE5Ma$i5RyNvOY|@$16PL{rm|j~`v9?+p74KPy$Cv2Z zi>rz(I-MoRhefCPn45*4-&Re@tc5v)s`h^zl)l#Tn6R!-?zFopWTD^W5x@SEEX1s$ zlg?`CkWSY&Io!*Uud{}gvk6IS$ zNEQZ=EEMfx7M2XWQGl6+S!axE(l}Yy29uq(>>1JbWCBT^8vwCUvUA#9+>-z4OeJ{7MLVxZe2`m>lXT}|!o2BLZbHBv?TtmlU z*`Yr-pZLuPdIcWnXvU?pDG!Un18qCwI6AgcbUonSwLk1EFIeboSv_T#A}kI_87l=y zr}v?8X(R1_Cc2biim-yoQ%0u%n?;(=J^yq6;Y61*Oc6o`QpQRF(&>hst6Jx)W1>qL zrU)AWdCKS%VBeFba|4@u4X0CPuQI4%wIJ8|?1V>XK_DEoB-omOgZP-<{J~fmQ-mfq zZ)gI4W{QLeqcj)A%_7=cWV47U2ghBgHm2wDmCrQT#WZMnNOd$e`K8ZRtD6t|nC_N?%?WGq*c1YBzk(Uh$k2J}SFS8;-6nZq#)HEy;oZ?cH4Urz* zFfm+Uwt}v|P1(@WOLnYjE1JDi=(j{&Hnj9uep1c*I&S})PG0%~PLOE1~cbEaG~{S#%`V42_&ilS_Y^yr3(;Rfu_{v%PQMv_p58(MnF zj<{)axom?(nHsgSp`}MZ5^g3vJEr)^OQOaNExlyNf?PB6NkpP78!QK0as=EU4TVQH zv~#bLwL6d~QzJp$s>)^pYKMlcjBB?nIdy zwX&h5M?Vs7KHNMpCQ+tFt!!xNB|CZ!J$7btqD&2z18$fC+#n5wM>n){zua@TOq8jS zB$VNXmR_amN zEAbG`&syW6HESLk=d6W!Xi&fLv4Vr;faWY=tJnxFnuaSxm?ZstxAVmc{<)uOb$7{% z4VGb~xc5&dhT#1_-*2BdM-rG?=VkM9q-!`@n7^h|p%YTmhV1Zi({ZzR6+NU@rdUp< zlxc#jEnq6T3fuhxgw)W|OLi>IjLjZAOq8j?R1`gbx!U4<9Gw&`?i`_D<;a+ zU@F8GV!WcJq3~GqBs1BaTZ+AyiKg$3sW|Q4rf;b{6O^f;%LMIzG#r#TM|qeEu`Qe^ zrUnZIrAIrOf99X&t5(x&EqkI^XSKELoULW2che<^*0r_l-2ZpWzPfx8Z`e@sAd}ek zJHT#fRK-@`iiP?JOEs%J9DEgNrs{n6sYvl{Tuua1nmWM?d_a z=mz_A6=8`Q2U={YL3i8_CC1~cPi^jZm7>&A`&-ooDRqhtj=nCmA@_BNsW+?(Qh33G zEO-8zkg~U0?j*{(z{P?LbeB>~SZ3xX+a4^?tjuQ>MbV1~YYqYgT@iC{u?u5*Ib0 zW@0L&y{SSOH9btzCCxRyS3}jMkKdwZVk$6oQki1w;?j12({ERHQYr|(n5kRKg)B^z zslyuSOU})z)l4iq>?L50MLHL}qR;k3nL2Fti?lZqW$KKT9i0kh z>SB%^`jseChcyxx=G3$~)<8@h9{rEP32f)1Srp$EOw`((l?tRw=kkS`$xqMU&rnNo zY%9^E&RE&8YNkQzobKBxj@u=g)M1Upr7wBSG^~N*IMjeXYFz7!i4u2eZ6=Nh3{pYH z5{6~xxWYbBrp{Q|8Ki=hx{u2zC(fQ2)<|69gqj&!*%@f_*TH|OZd12&camJ?lfY>cYvGIu&D`z7ygNsP3B}j-PP@}?A-E}qBD-bNvvkX zuLDd!!8@2x0BG{Bvd8pEon*35_=-baG=+jjN78Xg!P{f4Ya*d|S) z&M3?v?6k5n3KM8*!VUbB8jN(zSghIZUUw@e>Wsn+!akJA85K*yv8G8GOZ+39&Zw-7 z{!pBAO?1%13__L8$|y{rsR>8_*x3==%r;u2qpEQbGO&#{)7~Q)6LpQk3_|@GTSl3h za8w?&f27kH)$>UpYbk)-f;B|Iw z56^QCdKc!~t5b&a`Pyo|9!*^RwQ~a$RLh_o?*!x00=)FE9n0Bzof?%xj2y3IfA22hcU*3e)9p@ROnj*OOu7P2|kGwMq zabg(EP$3BCD}(|6;0HRQ_z1j+Y*H8kEpP+>VB!u@2nTVZI#sKo>RA&w0E4cTe!ILcACT+iz5W5C;51 z9Askv|3=bA%2X{L;GdEI$?KbtHpciG;sO5H}MPLfFC@_8~fsr7H|Vuz;xn&_|SeK&q=IKYVDv;0`~406qX>Ik+VM z#4osGV?xIPd4hZZl!c_goOCiBWe0co!GkpH=|Y-7R*(n4o|pgOL;Hm?FenEiEARkW zfe!#t4ou!EKEyA?gN+v*2c!x4K*La23@QB6ejy$K^t_4b!Hy}&18D|%ps{e~fB4XT zAs+ZC9wIC7fHVUiXh5>_KZA$(g|fu*q~m}zAs=XjipZGIenDPrKruboj|6!j??4`C z$nx<&d}zNQFZ>jbtPCLUfDi1%(tkf*=9~Bhd9iV(FVqRF7nmOG z7h`<@d2;Z-{4zeYUr0AL;GSFdpZ)QE99N;HCBrO;( znD`F$K}`latYkOw1r!VXupXdN0=b|pAnovAeE^ew=&-bVY<5s4@RJ^r45lYtJ)do$|+LX3M?6B@P#@G}puI9Yr zl#7}SbXeY-S&zKKDFh^G!T6y(PzIT9^;mS;cyQ9ag9(P!{rzFT@Y{q#rsg z?H-#Q`nRNyD|#hqfqDY*W7~oCK}`lRApdV+KEU7reso%(oVujLJXw4!%m*0Uzz^#I4uGJpVqJg;uzi5MpdUIc?H-#Q zCU+DQJR~jH9-@i$K}`lJ4h!=E250c2(*k&b_@Pc9G z5I>X$$^bH{$-tAv$HIJo2}Jl|J(xwV5FlKI_~9MO0v_z!i8k?{6;|#?{!V`j6DH~4 zhjHT(cxaCx{n##o4DeHvfey=iGy2dnz=Rt7Fm61!4sk*JnD-Dr$fPC%9hUcI^r2;d z$uIa}+;}Jv+69PT-j`$L109wRX7r(DaOQo(591c=_;@YUN4o#O$_F|uAJphW%aD)v z4L^(5W&@vR}eZ!B&7qrn3zkH0t$_F|uAI#`O%TR>(4L=%R(5Hp?p$`F% zv3#JziXqtlv{K%M|r>!Ck7yLjPz%0Q33i3YyFaW3s|APty1qgn@ zUoQ8d<2gPv{ei$gnIQ4-5W8q0|3H)f&=E@;O!(o01pp@e@PUK^A28vE4`c+;!Gs?^ zkO4pk6MpzWB7qJjzJnVi4Cr9OFVQ~#Mju&{W%!!WQJurIxT`};c6BTZa%tC37pBEU za2?t50;Lt;A|}ZW?h08zk|^KE^Mu;S_g_^0$G4U+af zy_coTnwydxCvedn2ZJM8O=>!p|KO$_=>!*z`KMmb+=ow$m||CX;HaPVsuu`7k-CtE zk1l}cCH=zqcl;q;u*dL^9VBr+iAfl}LSe#>eq8G0e*LJTBhNwk01DNfNp+t$%+cn$ zMl|;d;e-mico94=HGC|5+yG8^AWEpWP)EgjouX6Poh4i^OydcHYm%gPT#A&*lO;=@ zG)bDYsZ-f!NS`iU`m||MrB0b5Q|62g*|KNNk|k^AOpdv7=E#%RDR*wCT#h+%X3yr3 zF@wExzPxz~7AlaxXt5%N3l}L=u%t_g;$_N~E>)_uOUdFTiWMzi!L?lFDwQf$tW=?V z^%~WxYHMj~*3{IfUbR}4%H>?kmdRfrpK}ggyyE%N^Iz%Y#YPMdz3pZZ+<*Hm z(d29RtW4i2fsOr+Hn{NSRP8F2r%f&BUZv=ytS9H+PQ4`Uji5gE1sd+oGI+qcPJ`=p zY@K`J)G-wvJpVD$XUF|f!)snVHuKWGk;6LNe^hqq*|cBFJB8QS|9*A&!S^3%Pu^*^GIwYI<+D735ZYt~T{^nIgwN2$OI6bWpdL(pt#Gy7G(_a0`xaL;S z%%2fO3J>W$uyXYxhs$PM8}4;#_vfLb=hvTfqt1a9>94#wo2%L37QHv@U(;{q%U|sp z1((QGB;xSj-<+q}Ywo_dziid5ht=){pDKUQ|M{ACH9C|(_;FC@;otw5Qh!p?XPTFO zDKBiV-m=KyeGe}rU32_;>wCc|c^{2-eBS-b&(Z0AuDP9`j>!`c?sX^R^FK>x)}NGp z!P-lw(pQ>hpR#tu_&e)s=5YFza(jrMQ_JxURzfixSlhFnPz(!5O&xl>RYViM7;>bH z8Z+$N#Myh>w%bJ5KcrNiyOH{X0CYnPq= z{6wwEhq_lv)2LL#hpUG!UH;%@%%+&I2QfcJt=O^pFTb8eHWk}`*0sd>Z*DCXR&Mh@ z_O1giild7!A|i^29TAjbk0>f4D#}?&)YxK)U6dk|J9)W5Hfx zZ?RzSU81of^3B`b|FSpiArkdFBExT)otZZ~ug;sD+kLygQOgx0FD^ayO;G>Qdwwez z|4T@#5^LVQDn8{^6Z>9^uXouLJ)wmER`-K-H(D>M|6uro5)S8mZ0dE~>V3FIy`qH@ zYTpeXH)heEKW=vQw{FoR?0Rnx$H=d~in{h!rC!emxCfg z%M6{9EwoQ`_>HIk%cKYuT#dLkb;-+u#j;N{^?n#QH)r$u z@4k+{dheHPcMpF1#4Wp-?n>yX){pYl)dhr|iizKrWp3+Dfi2swvgjHS{Kw1<>+J5X zx;Sa?itV-~3kCoA*s)3WNyRGrtqfeB$?w>=TOxlA5iaDb{OI?f<5uh2246_HyU=t= z_KT+{uQDysq|c_rEiG=U2_M4k&?>X@W?#vu( z_0_%?mFZiD$=3_xA0_?$wT1JR#z;_nm=v>o)ff zSn$T<`MhH}ey(>RaX>)gvwL?oeB*rP%2KcPh0NVfz8QY>&G7K(3cpRba5k`G)k1Yx z)xP_MP938-o9gzzy*(HcDpjE#CI7x^r%yX^6dM}z*kk>7#MbmyN%z7cs-U(w^< zC%nGS93nbhT&B@Yp9cwmyk}Ymxcg>+OpgY}nX+@QUg!`oA=N zaV6yUxbaV|-wo)w?!@e@H+*|tZgMBb*5?DyK6qTO=kJ@mmOcLY`pn5^BO<$JD>3Hf zx6il#xZ1mL=&d-*M){xbZ9cI4fQ7AN%2q#m&9`aH!u!!ZL!NhAzkbe+gTHyTeI9UQ z->+AKnosm-{m-0c35(;_-Mrpt>%@HrJJ%RD9!wcUCo8T^Iv(>HO=}eID_+ZK zk&t-ItKMo#SG=$`!HB*}4R4lWjTdy#}7*)yZzlj+g)Fl zMJ*PDI_wac^4@a?*2C%fuVaPys&8trPBr4+^pkQ{9yl;TEK|`>b!x< zvj-BWkW`jM%!^(rV{bN{TApHIoaN1>a5IbV25UzJ1CwR;YZ0;$CT0uL+V#w#2GtGj}`vNS_v0$Aa z70cr-48D-+;R|7T7Ta&&_u@Jwk}NRga|b2`JIev3WuM1h^%i{|%bCT|ISxq6kk8BU zZp|U(fo%XoE(+ZAN6Pz31av9@s7VKDHw!tu~W<9@vaW z5&#de@HtkSWO>*TGb}s=8*$R7<)h2IYu)NHS53oEs|5rY*Uza+{rm^VT zM4#6$l2({r@hne`&vPw#vZwM&0YnRtL$ti;mGXbo@)V1dEiY>B%~rbJ9{$5WuI2Ho z&HHqtm3YVNu(;ZM;srKKKVpUHARdT?&#@P6$~5Z>vOGUm>m`ci@fKE!?a$MF9@W!1 z-RHsb((LojM|M~$`#PPx+8iXWHd$F*Z4P?xYI8zt_XEl^Vh}Av4$<+>Jk2C-tV&QXG9{Ie|Ov~t3pfAAZt@|e1 zdclx|p`LspEDx*AwL+IL##7o^L3;nW0|TAqc^r>->SUkCEKl@#%<@E^_kPQZ&c8H9 zeySj8QiaGNT3+-@`9EfPSZyj6srGp%_Z(=F%;!BZmt+>teqW`Z_bD0r{WV&K^(fAO zoY*1xyenQ8Xe)F66M2@rD&_yM@_XL#*NFiTzSnhMM7q+)AQrOwq&e`7H(ZSitnf;8LHxGl$ zlRI}l=luDdZ3+}9Xyfc$AiuM7?p)5!2iO?lfBZ6E+!l7A+d7u|UO4qO@z9x;k@2~# zTJ&EWT(bY(0Tmaow2avq^iz>P8qJ*M5M=dTi^ah$OIB;S@8Ik_yB?P;5Yg{QcAwRE zuZ1qlH)2i4GCtv*CkffIo_hCjOdyd3zv+&Idu27bxmHJX<^mx<-DL%jYeK7;_z@$dmpR44F@|s zG^=lQ)XCa?-NQotEh?3azh5hU|7~mcnUjA`@NJxRW{H~f5$mcAvB1<=Z?=NGLEY$LIpnY<=Cw+#gip+pYtKoD+@}KK`;}zN1ZuX-+x&pBI^i zr*ZpU=+a3TlBIu^EK_e;&VT55D2uRUuUGYs4!t|LGWc7aib_9rmr3HLk!%PHS zubBnAuOEK9as3}xPAfC9S!|)Y-@A49Uyy(0UndU~59;_`x1~9&Ogq%gd$Il4F?n3- zx@`EpS)=Z)e$U<1F7J2M67Jh~?0a(5nKF(`+`Fu=?@`+F)Ou&f-j!=zt+}gr=-99^ zd3zkL^?YJpZ{KX?n>O|L!tjRjPE@>$zoLX{&YF2V5-qeXjOf zUr!!zf66(#mGhpR{5JZVAL>2Xd1HlN=VJ{zuD5#rsKU5frW?2Bywllv^3Tghtv+H` z^sgrN(N0xOx3;

d)1unp|l#GIH3$J61w}S!E!zxY@g;9bPD3LI9=Kg=b-TBqSf&=mo7_e(^ z->7+x?nA<^So9w;)vjak{j8Z@H!!;sd3kMsb+v_mzub1yB#Zgv8B1PFeUal#_EoM6 zN*3PRuibb=+^X)&%xx?$UjK7u;)RNtHx%mrx~qMsB_*vp=kV#(Y5Z5+ zt*g%M6LoDzzvZJIw6n@l@0-|njVpTYSabc#qJrIqTICq)xpjFXn;ruNmel!v$?}A|SJLGB)xWOz zvU|J#vhTOZmd(OBYu0Sc*XMAyw6t>0k;97ld`q?#ux4ujXOm2soCOn;tj^}<&Y4V2 z&7HGk$>MBg=A7BgEVHwzX)(dMXf9`KYiHX+g$mlTC4e3C??oIOob3x2W($DAcJ|KB zj!w=F&Uy3Y%j=vck8|!kdGaxT?_9vfrl7NpO#!wJ$nBgf7rC+V4No`H@corq_&>?; z{c7Kz$^EaLK`&0#CZ=6JWnEsw_m4=hv@CmH_Wl1b-#?+4?@#3Wf8BI*jtEZ$N_{UZ zf4*VE+0);5YG3Mcrzb_DclA42s6@P3b@LT3=Y(!py>5Wtz@FPiZu_&4W1*j>Uw*NA z+KQlEZQec{nBVXG`kQ7K`k(&x_bRz^caHJDoxf1v#Gd`{or&&Iq00P+^MhSuU$h^) zwolyDwMQO|jV^Gaa&*G7nZ9%86z;ryV~M?kj?M4fw)gJv{_A$P-`Ju3^cNNVkFL$< zHKRvNmB4L1jwiH>AJ}eWkMpbV#BMp;F8WdH7F|1TyZTd)fI4dv3J?tFpAV}|86DeWNy+G#c?*KhUTW==7#{uWrK!KwkFQdyWklUYEndtU8XOT&uI2f` z7xH)A|EP73#MrO?D(ly1L&6`s3r36!SpLYYSpA3LPg=%S^f*22-m8Sc54#PyW-`C# z^{{1$7j|}S;$b4Z%hE4+Z;RX0B(7!n{|x`1;s41NlzV(bzwx4;cH_QUux^#w|F=r` z`wv?9;I#`Fm#`|Y#cgqdQZ-UptZQE?_u=!ykLZ02JTywkR8sEl^5eWwfs-d5{&wNg z%eu!dtHm85dJsy;GDAoda+p|~2q#ulX*yUChRR*UtY?(qP@s`i(~GrP%Z;=(xaC`^ zpx&UUy(=WH^!%*#W}jPpa?jDy?j_%?s7eor50hal5^1gJ4F;C1>8%7p-zYv!Nf?Pq z-g%PmRZy$frc|0cKKn~8J>#YZdul)*W#lCfzFwLBr~&poRWVh!`=lRgcJ4U zij)TEP!#_5p6zLzng$e;$wq}esF7iW7S>~@8YMM~9Au1>G>uUsW3LaxX6|9=y~;@;AU5IW!FAml63#8znWMLgIffmG@*C zg#>Dlk9piQ#we))6`ev>Hq3E1T%Q_X&r@}B$57+EBLEeW-SpAdG@cqzwP0e@LZg(8 zL`8rO8kcy-9%-Ke_UM;7yN=01Sq%7kW2Kryq}R*YTg3XwW3_w`M}p=g;w( z3&E^?n;lwHg;7#xhziv6AIcC~w#l#mgD_)}(aVmf!XS0u2tSWcH?lLNnW*Qf7BWpc zR@6ADgM$)tX_F2zGGup%5QERL2!BMq*8Jp?QQI9)1*qmf93$M>*6#0gCp%sP4N^C9 z&cje6rmmF^H&WygKm{*5*d1Rl1n>As|D}=iFlX{qfVyOwxo+?eIn$l&cq$B1ckSYL z^Nf-@Xe4d`)N2((vg7AcA$+^7f4Za2knH%`Mi_lH^Ak07Ro@Npqs8ZbIUI~N<@in1 zXg;CHaFUYj6!jLhavl9P-iuq9V$q6vu){&_gJ}y&0C?2%@EZpHt@-1z@i0mzOd>@7 zX^&$bF$x5xmTa%oG+mRPbzhMJz}Y|W35&;kh&mc&gk>6H7g(h@LJ?7)GEMH!ah z=+H~5HexUx1fyn{0x!b?PN}C8xsC8fJLPx*kU*5Af|co1ns6Pez_ln(_EaGO$k!nu z(;+6g4gw`wsEu%;JQq8Z#KDr_>Cj86F{q8ML%CXL3cL(U%A+VYHwOAsPB3^|RlEiV zOEOU8AhsnrYNCbu({)IZD890iI9O_@Lodl=(KTocx(+EL#c)oRWLRofjDj13c!KMY z5g=r&cr6Z=+F>ZXUj^R?AKCzxpSTn+!^4scAP2sUaDo0|c;OkCd-VO5PZ2F4MqDhGQ|~JRR7Y516>>A zh*y)ZgL+~z;X`EzPlVI@mqr|D3_6q~Uq@XJ9Q5Fn4yuzh;y^MM<&6Gf-bzPxG&XdA z_<%Zgs-L*N`i<`|k&N}^EMJf6XiT&b4s=d<8BD;%Ab@rQ$yk&#`iprh9o5m8G&W>G zb(%PEeHqvXB{FV0lq6pd<5G@u(g#f(&>6U(oXT98RAu@xsSsWy3z0`GhdxlAEOC94 zwZErAZ$c(mnHIv0#s`m}51KeoKT2ujgEE+x9B)(|j!1rZfACzbjqqmTeX(79y@o8M(K;vuS zz^bK`Mn2FBC*n&dV*jM4FmPGSNzezzUnrua~=m;n9_l<@r(`0fyRSv5Ds*%g#+K0fu)#u9B2_q2ga6cvyY~2k}hcB z!1qlN0oKUlKsQ3-%@8M3qMOE~oD$_UKG|oo#Pv3lNd1M2A<^%S$y)zU)VOHd-j6N?coUi;jERnI8eX|J%nerd1e%a+wp4l1LL<ea*kmZTdgW8|;X!t2CPxfsrQeZNlC$cwb2OZK;*ber~IeZ>P z%Z1PT0xZwkwcTOG@^}k_FQj_-LRem!qvg84>3W#W%Y$W~C;2|HEc!gj_d!~QEbmAT zmu|A<8MZ9xzQIR_iz#J@KAl<~@AE_pV?-(ziFjTVx1*3r%T}M(^1xpBJbg9?DC~cq z<&n>8$W~lmNVMETqt0DZR-3$q!SeW3D6KZr94+^n?Tuj3@gT636b9(N!sm`V3W$QEHURr&&p{3k60djo??+|%j-}m(?|X)ip*_6yw78+%Va(e z0AMp;M!lSq&!cF$U&?CJG?PFEbb9!Mw~FP#!Vnc6t4;MiAADY^x28R0mePkS=>CpU z%I6LY!Z+@DVF4>k>LT9jk=4ofcgU&DkmY6E=P~B!-Oo{(yU!DS;j70F^&{%gdr2Q9 zLOd*wqhq? zWR_B7c=`?zrIgPd7{og3L0d)3BXA_q66O0lI!Aqm<+0c>#02%%FBRWr=sr&!CGKsR z?Z?%t&5EsNjiGy-gu~LY*7S?V*56%b?huKKItxnt$6J{ioGeX3DmRG^SZavvR z7RUjFaz==_&m$Y~Tg)>;#4$CbDcLx}UK*5*YAaO_hW*Z!5hCt0+D+14tLSfJ8^Tnk z>KDe%WqZ7B=N97qZUiE(e|2+VnAu3R> zJp793efr5>n$h!(k~+war@|n0LsrBlq#N0RI$kqT&r>br9#wg$aZ-mxgP2R3bdV8G z9bb>w2ZCpvWnGMuI@pd(B`u!}QGt3zcHqnU=ZcnY7+K^qY(W?f5eEWc74IWF8N58xp&pEKkn4k1EqIX*7^UyTzyxXf z@YZE!6(CSy)O!d|rhzg%>Ul=}_2~OLM$IU#IaP~MAdqJi>UqLZufWR}MLpo9>L%46 zec#eci&1F`5r;we!KJ}IT~xGWt?exLqGp3X7C*U)XdNykByc_W(>F4 z8l~0@gCXLyrQT#4Uc04S{R9{7QY5o~kt<1k2!`efB+Uht+(_3ac!I$z#MDIfz>Q}L zwGlk!^v*Mq*4%_eH^EZ789V4bY9uOy9%USv>C}hX2`_rb8i~rl4ce<7hptcWWvlr{ zb?Bot4&LKd)01s=zFq=*PA(%v9AlnZ=y-6DRVO7`Xe4Ah#02XR^Hw@2CMgfWWQ2&5 z*o0Yz6q^*4_(KY>7g>ds#U%5T+7+Xa`3t`YBctn(5l|EeC2_FS4nskI37-HRCIq?; zy=9#dB2M8VJCOxJN{tzmnu%E?fE1J5H$@nYM!Gf~N|LXGdNNYr0^upJ{7D*dpfTuB zl6)O?J#f&2Q#zA>paD5rr2PIlT zsaH{;g~q0X_zxUte$d2$)r%>Od?05n9C-EU4vm!e1B%Neuy~IT~d;}R9&S~!C6W^C_=gWL( zG`caM17qXa5%L!_9?cJw2nU)Uv~b}25`0RD#~~v`9OG6-h`5wg=HIkYh`3}MKk@~! z@q`d@4p?qP8FPp@1gh#k+Qj2()N3(l$3S*2h;PHw8}Z`7-qoddbj3rjE|Db@fsr^x zW&_Pa;xd4i0(^3*ZTH~1yDhtdei9?D>Q{-Sk#+9Ww`uj4my~Z5`-w}u8Ph4<^I{{h zv9TpVL(-}vX;q%3efBk9RXj45u12kRfq87HCySMEIRhBIcxjo=uP{DP7y+Eq3(Rz$ z5h9M*XdoH>O+mjy>fuOU>KB-m5CM2mxp8@cG~y~fk;ig`6o{hwkYf)AtM|-}FGSpB zrezc&PHlM>EOd@+ae7wvAF{m5htH1`3|ScJDRcmxBfJ1vUPg#G#ssaDdW+KPoxCo2 z=m5pS-eY-U7@gSL6(=`egT%Z`d+5|%4$;` z76<28ZK_wHE)feTlBg>-@abL=6 zQw|Zg^Y+Cxisj)x58=PD+QfYx>dEplLc~D>x%@L)o@`;TJWZe1H>C8rPiuLgA3hId z{1la}oPy7z)h30A`vQDk&A;6@i3=vnU*Q?Fy%Y;U$Lc~S3@EQ=lZ(jZA?5<{)%-!vXA(?51FN=T>ah;d9 z=rcGYL>y)#ad%W-Z<0R%kP#y8v%Ea5h(Y!UqHH+tz{3a`A>uxdZ1m)i5h9N1A?>$k zgoq=9%!OH$a-36xlngoIxEMen*Xx_oEC6jp$A!bDO;dYCBa;pHT9Jr73p*w!WmgCl z86o06+h>3LN67tCcSXM~9REV7YoA|piH;7n1_JfoS@GVCTJMBL|@q4Ainq;X$Nh&Vj% z$-gr!IK-8_)iEhV9Nr}sW-U0Tw_l2>!YG5N8Kgp{j(_V}Sdnn1nAQ!eQBnulC8NR+ zb;n=ZR!Mi%@tSFn>U0%m?0uSv$FJiaRva*oeK%3im8jY)-N+8qC8I*t%pV(Y3~t36XT|SdX)+Urj~GM8V`?po>AYdiGOR< zjMAD@!6%ptF$x5xmTw=5Y)>Fq1LcU|L^#pxj)g5Wh3`W!r2a_i1r-O=5^ml6$2E(15Map=W%tq^hOgZT~)gT~Pc z5jSZ0u{;8Moi!sw9AgkM2|~{Z5hv|szz>mPladmDNRe{0LrL=L1F+OihhCCr8M+23 zFI|TeJ|je&AXwWlMkGtzv@Fhw42T#f&O*sLs4BR=s+JT_X$*`b0?OAxJ&jF?a;;Dr zVk7>g5eK?9#t|%l}Iw4m1WGN|LXmt_Kc!a7qW&Ng8n=8H;j8 ze=*Mp5eJV(vL_uRJ%B8zj?R-Mj)%$G-%~*o7DCC0pz`%FF6B5UebB@~?8yEB7nD<( zE0e0M2bgRLFHFvKDdGo}DNmNTzRB9(Q$Z89dX)lN2scdZbO{<8vZ1nON+TaKLc~ej z%m@)D@xh8^bif`Yoy-Ukho_e$E+x%Lm>)#nf=1+`O$O-rzG&uiJ``3)h`5XpaTF>L zdO?Ai=zu;+HkuJ4PMV|oh+!H+H3i;Wi^z8%BW*GU5XM}^{z#uHZSs7TzA>y z8IK12b0fcw)wRjt6wfjP3G00107Dr$Q^*B!8>Sb2u;N8R9VHOM+vB+Wr-CEg)FI-O z5CQ5Jl^Ki!J(0(9goqPgU_N#HPbc-B`Ny|BHlmo6&;ektm?yn3g~g;EaO~4~Y>BSs3awGd{rb=sY7t9JEa%|M(WlTb^QJ z@3Fk7x$K#|og>FR{}h(@@j}GG=b19ig3tQ`EU#hpiB}ZM<1Gx~a;P4`8DV)DA>uTw zj;cPrgn6(Wu-k3z(KDXUF6L|niT z%j=5e!NTa?4*pMlpNIO45OL5xjr=oO9v&o{chg(PFwyjRJ0DxF`?Qt^9>C|J44;;) ztal&ityB9vT5VE@xG%ux-MMi4foOTyJyEYJac@T!iF2$rGeX2E8l`{o87zKCG41rad854-O)c1};nRuYryw%ZHg{5pxMNd$ zb{U)zA}%V+rKaOHd+X?j4L+ewsjn7zc!XMXbiZ#L!J&YnJcklBJoZW%^X&YCt+EMyHW*TAT$f#1{9G@cqzHU8v!Tce}~GFcOu^-h6fQiwRz0eQ5cEcDv9 z^o3DUqhP4A8y4s8_L3hxD%d6NsWS`N;W+9N*Q+3=+zHHjglJ30T`3r z;2d@W7?g$M_v@M)B{f>I;jvfB0IqsHmtMeOqgmNN4id&vh&a>%d9@BaN}v{6z6 znKaolxPSj`JyLgn<9oe@{uetKnMQGc11jpYt@o&DY%h@--uI)77x9Fr&u6?eO4)#l zyl;m@4?7vIM~#BLtYJzy^2iJiqof8@NE)Xf>Po>L_JaK7oPqX6Nlk{`WZ2E;2@&^E z?8dR-z0>rdWH0&kWNUiJ4vROV2{VSNnOrK~o95pc&VFHH-S2;n(ed@dt*ejqeZPe7MWoJk;QO{E?7;Ts_ z$V_r((k2~b#M>9@9pnfUYyK{7ANjyXC-fCcG)XtIGeiaIN68^2Hi5cfafe13C3Pvu zj@Lkg)IAtDaFS6{2aUvy6nO+tkxT>Sh!n}{tJm%N#we*H_a-LQwisrQWK_u1CDY7t zKkke*O6pRQT{0>RQFms0CjDpa7{83dn?oaU1E5~37?K@7mkL!Y|2EqwWtS3lhGfUj zHp0=B4XdlEOJ5=4FtLh)mF*PnpMDzW-$Rnx3`a7v2j68esN;~~qW+*R_%9l4pEJiof z?irpy!%gVfa_)o2iUkC+b;hlQ=7J~XkB=RqQ-pbr>|$(628@C1YRqS>kR zVs;9l+X$Ze@*(0d4onWWeFRH5(Yw^@fHG7@AIw9T$f*yt6JF}zDRT9+^uP}hKGdJCLyDvh5y!() zI~{sSg)5Cg*CB;ZZHPF24B`o{Lq;Gzr^#|kJS?@tP(Y6a6QBd%2p`%2&chBQ9+nIT z#>2M}F3=x}SW^HOVL1;w;?RTyA&MED{93nWh&Tub*MT7sq9lxz65lr^SalnXfpNro zS!k%Iu_;lWOmW2))jzqfswP#ZbZv}79Y71}iOGZyl_5NKs+rJNvoVEA8iNic$+W2J zfrB2L(m{2SMm~^?=>QE-YO15Lp##JR)Ui{&#P`)}OhtiYtS4ug7OJB$(MCAXIpJk6 zrI8OLV>)@u^|hp)53x8%fLP;k#W{(}b;FrAR9*Zyn)AcXw6f6 zUxNRTM2jT7g_2AQ#zIc?6JJo)93zc$EaA4I^N+Ta=Ax;PM0MGr%S5@XDk_G7}9egs>mxn_c;ir%zL>$J( z(>kyRj0t@}8P}tn@2hUpI>*?^X<TS(BnKJ~wm~@1xfTw5Uj~+9!q~`Z5lIKe zmiXF7(>6&Lv~b}2ricJ*#MsE`Mu-kxrbIW5NjW9TX?(IzKJk6|cD{_Ukt0MLFH_<> zjf*jHjQTLF18LP$C=%FD)GSz676A!q~{^W`GV}rZh*< z_?Qm}2Rhfnf$z(}QcM^ddHGqrwg^!fA>yQ&SiM3cu48tlb0m@k)l&`$Q5#tc)l-gh zb}CAZ>PdQ95+s;Uk|;zRwpRJgFZ@z~%_{s-K&tTZLc}!`-&8*1)rRtKZh5Upc-_;s z)-A8!n|xDw^pPjZUM3de3L9i+r_{@31gfHNIlKG46+^^*0WUBQZQG!%!Eiad7#|QW zfX?Y9XS~3i<`8j#v5Aeu5OJrir7&?~&cebq3mPPbjiVgWBIV|zw&_^iiL!ka7{Dgw zyolu%UgV^Z3*hU6qDFe7zczKmJm{iRZ%Mlnwc&PeTAmY22OKckeL5dxwFk>k#i z7rj!JMV?+QPqDD~Se}la$veEKXaA3Dd3u({d>+c8?{mN91vca6QW6gP&rgVQ89whI z(=7PBFTnDGSKlh8SRQX-2+m0L2-*S5OLK_0_~rZ8X@*5Ty{44t^C*Y3wA_%6HE#N? z%LC~27pvS&zUz7Pc z$={)?7?_y(J1Ud^L%ku(6Ds;lQFi+P43R^`yy%tkf6Vd>1!oj3Z<6m7{kO*d^=ebR zzhkRPk?sFHk?!x#U-9Y~|LmIE@cYWFsVqTc`M}~(k1|;vg^2r7R-1B&xMdaEIVqM0 z3!{5G_&@c19_neeS?aB651FO3%A|1Mlu|x-U=Vk2o?OE2MFx8{JN%BVFxmYb%c;EB zu{ra3rNx{sMahum{hG7;K?y?RKST-<0|aHXr`Oe{;`3zR2Fug*d6fz-^ZvL#kGDLq z*K*OXW3QAwlP1ek-{(3>AwDoc;(eg-Q zWND)0nB~2VpnJX2Vh(9$SRM;-OiWM*;a4or(0!gsH2dk#^P0Ybp{zxueLVI` z8JbqmzqsbxrT=$ov}D6$4;aOcuKdugMY@p$Z(^iMoTt4_DUJRlgfB+ zGfHY82MJ>-L>%gXJlaqetU7EiYLwI{7^>`s$6hJJZr&U}QOhW)fgFHwlJ{gg+A{Wl zL0P!*ypiTx)c<$ysU;g8d!-EE0{x4}8>MU@lTIHJBJTU|a|RnFHK3wNDni65n&#bp zUX)Q%11cOeLc}T9L&Go&9BF;vs!>t{DkP254-uD)8c;Q9{KAJuNlk{`2pM+sS?;7i ziru8Y5OEhq-tE4MJ$Q!4J@KCL?V4jpImRTf7rtHl%tC9bFq$B0nB-{rV~7gWL5Fw3WLrh1LUxSQ#aCkeTGnq!4kC z5l|v0)w|C!M zF-q#7k+_l4nlqt+usdih>V<$i4N4m&by}Kfhzit0riy0XyO&+_+XMf1f0vT%cq$B1 z_p_a2ccYXYG!i!eYJbOTAgDt<)-b}a+XcNKYWSh!|1P_fsC%F6Fxv?8M;z4qHqL)5 zMBI69VG6QQ4>lc;ql{wmg%SWB^*nr^sYfSkX}-|}^wRP?{ES8~b%4Os63)Y89!EVG zg&A3;A)ZM!k=4Xc`y`c+~TZ3hxjZXxthl|JbFTQ?(cc0#i#k4-eBr zJs1U3&9U^bjTWQQ6e13T09gz!5ypppQ^=K`iui;f;v{YH)?q}LGs(yJ3+-%?yJf;taWbymm`DA~?~Ym z)WKJ%4BWs2^*D5W3P7Re8`YtY);I)DW2ourZEZ4Fh{^~Nr(=8(g$<$WMLwZMO7ag1 zBxE`$!8+jBpqO+Wg3$^Q2Urq39ePPM2DQ<3C|3(jftO)PS)kZFKIl(5!Dxku13sic zP+Zhu^-Hu+f4UASk~%~j4@>QI=p_}dGzMLVlu<9T3OdNJ)DENI#~_~II%EXu5OF*# zwZl+Aj|7u)h&UdWWB@tvZG;OMGtos6Yt$j)c-V(WY`+ttGD5^LHYHEQKsu11(5NRS zYt80>SLf)fu1n21jX{T!WQA1M0|z}grGx53?yIUv)hQVq9iRb9O?8-L=t9I7)KOWT z_`d44)SQ!%(V--n7OJB$(MCAXIpJk6rI8Pq+<023p2noHAq%S0!h!G0z&8I5EgV?2l+wrt zgouM4NHl#|h&aA4P)coXOd;ZUT1ZC3d(sKmCh3FLe9iY|U>}r>DMTFf0MGq^5X?!W zi=>})@X1hL9u8%MpF)lhaTps<>%bl`CgA`(!L^X{eNk^H$JodbA`WBYSpltilJo&M zsjtuXRkvxKV{GII5r?rQzJ6GUIKHpexavBLjT|B3c$xBZ67+%O!6&{i-_DmYHgbfB z<7J9@8Dl~pP*z`;@2hUpI>*?^5h9M4DftT;Pwle^FD)GSzFOm|>o7KQgoxv1N^=yA zk2wjl(ZYf6s~%759AhKz_(S*QLR3bGILRAeHYCmw*Wn@P9Eqet^^`+G)TW-za8C6k zHG-#HOM}DEPw}lfmxIw%f&Lp$#ShgRbO<7xK8v$9%Ia0^^3}^ z97Rv$QN21`PPbE+3#<3cP5yPz4mN_AU}<6=a>h%{yCj8(lU#Z75OJ_L6jF`CLNYf%6d~&I6_u#s_ExUq#qFBdT zX=I%{^=(@HEaSnnM}!m zI-VM^RWM{>sL#gu0L!Cu>X_ybaZgITm@ANV?d-c;42wg#Sho2}q-&>~163`{8<${b zrtAM8)I-r#lqfadGl@t=xi=d|Lfyg9xP4teT`+` z$Jhu<1e!{a{T3c-*@IkuawidQG`aD{7%IB0*BKNH2^Opa1>|oM6#v&-wJo#}MEMs`lD`kj2o%+0FmM4CaTo9Cc zwdIZ86F=eOS{{F&2OlWrY_%y%BWVeO3YqO%K954geJQI=IYeB~!lrSG<-x+}-VXjx zeV>PVT5YB|L|n^L5v#=eJo0HdyZpOmXsn#O#8X$%p!zVGcw^<_e%R3YMG z{@Psl_V_*x78QGX&FN*=QG|MC`t2YoMBJ|fo2?tH5h8B=K#9&?tPPtSvmqnEvOLF=L{rzMk71c$2l_?=aN z_mCY;>t@?@^wPi`wE2QM312}#8_GgN_~d+Qo*NA{3WoA3hN$7OSISsm=Bv~|-vzKv zMk^a0dqq~D=IF+4nr~njW#|zed!-CPu6)@glTm6KN^asb9O3*a2Loq$1Eu(2QTl~HP%qCHx3np~$)1K??c zOGg_eHIReT;(e8t-wY7#26aFlZ72)3m&|oBN@^4gRkGo+SIV%P*`uz<7$r531287L z!8z;%FenSf-&Sg3l+GSyG)ih92VhKggLBvkU{DrTJoKAp zl+-BNqcx|=bqX~AZn|>DEu*AHk%Nq>o@{`c>-MT;+_7bF@;Z-7Vb?siH~sBh?1` z|2p@!m#mRHlw1U0@V{THJyMGcpe!|97$Fb;Q9o_~YO%g1nJU;zGL@-e&$*#II(+Ka zMoA5*z^W&S8Wr{;6)3a3zqiFAqof8@z!xQ_22^;vV+&Br;Sb&m3DMR5-+4w!e7 zxpcX|;1ZolGf3!V2_jY8StP?M+#$y$Ixo3F%2L0S*6S;~Z>oDAHE92_arq_U!vV%Mfp$aO z5^4&0G&lSI?}03}mJHDBWOnQjSMpZJnB?}|^6$=TwPg8!r%uvV_FrY!f*~s8`eYhw zZ#&00!&0XtyJS=tqVD{ot&@yWcAB@s?~xr|Xw}`-#U8xWLnr*&bL~>2q%I}ROh$!F z^+?&%d=2VmT(FyHl+>jpJ42e8jJnZ_3N|-N>NK}CWEt_YE4Jz7twOFbI=)_*+u>`? zpBRmD&NM^?>XXUtL5b-t)1B;iDhyJ0r`~S;k9{+1rVW7qyX>@X%RmLMfv86$Nkr2W zcGlUX`9-n+J9S!frXea&pKL|;VA6#uMyZ)8$+V2e z9{Vo~f&>UcakmFXpq^(yViEnjK)|D(hkt&jRj5%jN^`LaPN^6L0(nNEo+ljjyyHbZ zKdJY+xn1)C4WrR0&2?`Ij7lxx@B=(N>UlbloQZmV zuDoJZHqodVrL`(ZiBYK~ydk%f4d;S-o>6tLPSN~CMuLn?yy_W`E2qyk^1gQ}SIjNJ zdYFk*T-e!jFUia9m0@$ibMeSZ?S{Oo?1?|Z2Muz!UsK6(*4H~Miaq__NB6z%L(2u~ zzu2y&HUEkkJjXvZGw?x!4<(+553N4Bg_;>f$8G6Ci?T?0U1LolS1IvQ$L$oJ!l4{5 z_Ypj;7YuE*q7T84i$;$aDn4!tBVgK!N}8ah`ifC4YW5)2)b z_%VoqXs5g|0m(@Vmf-c0JOB^->2UmFuG)JC{aUXUF~JS_2C<~u<2 z*3;BR*P)z*n=HxrkTJke`7zL+a)K$Mx(E+TGJqWTr7Y1x{pmVn7`E&{;$f+s4!xwp zmByg!kYT8mUV)ckshti={20U&T!)OsfgMOZEVa`?iC=jVO@u4qLq=GL9Y{PZ$sm~= zWL)VQgezT#jFV#YCQC9bje|*rAA@MZb;w{HRTtr5)$y_Ug(BfYG!s5FN!YOiiHD_e z=+H|tu5=BenXW?7a%wQo(&`p=WN+P}t4|sl(K|M_bln7BW z9<5}kuNJIU9gTr;#CBN_sHd?hQJ!p~5nELMELNWJu#W^p)w{ZcB+^7 zzIu(RD9{*mC`qP8T@M`e;FJ!klQi;yWK0J?sZt${4ILmpppKpDCBCm-V=4+HV?8;` zv``(5i8jK4&IvDrDUEy}8PmbjLUlAIjSX2)ofZy!Uk3I;i6&7xlqA!FaVf_+>4O#y zd|#!U$`hJ^>EN9a;YG3_+9^RFDCZO3mv4VxnI>I2lqBzc>V*#J108(g`||DY zE2|esBCJdc$%w{>%|IWta8SlbBOmZV4W1T~5sgne0a=h-v~b}2GO!Oy_@IW;Nu~wk zlRSU}>4Fvxd|#!U$`gE0gIj!x3t{L2T?+F9*(aa)zI^-p%5>AKcjGJb0s4;|`k;k_ zGDaHpffnO*@U)Pw()c73$b$4i3kSY01N)$a4{9i#WLn5BXnc|fa3GwtaA4I^N+Ta= zV}%YwYhxOp63K!R@q$l=`toon<6|DkY4d^(emzF|PvgT52nRZ}aNzqguoM%M+dLlw3egs)ayw@eBk@CZYd^=jogVr)4}UDtsiK7ny)FP#0S2w z)Wh(9jE&rxfzrY2Hu)?XpY)Ov;XsF$Ecm_zpHjlu$nWPk_nQ#KcJfKsEQ!zf&A((0b~v%anH>a2 zbS0KQ`-8xkRG%tX%8i*@E=#rYf2va-Xe1_5J>_&Dfw7d+fkXrnJmqvC5rI@sIUPtu z2-Q=Lb83TND5t|{(lwi37fyIGv6Jnw?K=Em_i}yjIoC$D(p|CXQnI;E(o@R~GtWJ^ zG<&d)q%g3gM1uI48ZTKC>L18&azBu}Y%bJ}ejqoOVLhs{3y4l}Tp`)vle42k@e;*~mj0?#$&#f?6fauL*{N(fmol#9%awJj zRI!3bmCEk!l`FYbs94^$jLTQ03m37s+r-S~a=_8;;@5PVkgl`T_kzpO#wB<6vf2Ol zob$)04X)y`>D;CRb*tnW`O~3xr|t5VNSO3s^q8-5n^#Ea*4AxdyD5`Qe_Qz1>eKa` z)^EGAXhg4`4&POa8&Koe%NO@AojSGu@3)P{{ZRJOu6Awrqe5VaxfuBmTU&+N|s4F|)sYmbmtZ+k<;W*6n|=+5Fw7Hom@czTvZ& zbEBs}es=0%&vXAY%X6gc#*ypiJgIc@Zd~8hFaGId`jb_W-qWhLE_bB*_1Ztbc<`d1 zt^K$GiEHlMdC)cd)u!LJmHVf_h!fXpHI3g>>!*4nFZF*Evb=?@eT@U%qi=L%DD+=A zu=tyA=I{P%`sSB|k8dqdqH)8RCC49L?^JI~*T_J6pr992@oI zxQOT%b>{D09D8BQ#=>lj$lCEwkJ$fY)p+I1>IuFr3Je1J$q*KKreFm4V+rP-eG7F}i>TUmK zv1gO8BjpEAk3Dhn+R#1U53TYhc<1X)rVF-wb9?84JSF=n<9?*E|i&~5>XqOS$L zsCT^W^itWwH_p!fXT6g%e&7A})%Lk%rkCn|dcV7w-?4_4mVE_i&^ z!Q0Nq8UGI!wO%O-<1b0!na11ij~O$>MA(0=OqTNJeJ53zG3loL%3negqfX{%8U5?n zELmQ!EjjF$qUB2tE4ixArfcE$#kQ4i*DOoj5e;S^>(j5_i*cdh_MwI17Z+=MU{scF zRiD;dvDCTp;5JpC_Wxt0^UEt$t3LIex7hjE7W1l4Yj$7Y96hv){pRlOCnk7b|IYsP z@=9kXoL$$z{`LOdrzcz)J*R5uoRiU5xa+dtmqG zj`orJ2A!PH>Z<_z*Sq?hn9y-#EBnX+&lfv4-ge${+}k2nxwhr_?m(?+GI3(Yhxwn& z{9?%}i&~0o_+HV;x~FQEtZibqzgHvwZZ6%v%|5}iO}*-ET<%p_aW**rg(E){w`x|~ z-Lma;r(zqv9(&>Dnyx1=Sp0Zk=a!$wxNK-Sc5(Dv$tyms~A{z z=D{=j#}yA5z2`#Xq6~82?`;lmU=90QY;Ux4$GGCF*KeIZvN^lv+Wm39eS%HK75CcE zaPy7ItY%L8+E_l8b|s?BH@U>Vf)G=tpP z+q-9#8$ZlH=sagvqieJ5zkPQ((SF8dfA5KXiay>IS)ke{(B@*Ise`zn|eTe(wl!u?u8r5Uc6n1!9aJ-V)#ZX1L;$cTsbtH^1l78|74wkC4#E zNdiuEj8{KZ_3uAI{oC`upQq!3k}#hias!snbAw<^!WoiFU9zP zdOAnFD-&;;KQ?)Bw&_seTK(}gYTUn6<65>{QqIa>w{Po3Wy;wAV$w1O9c%f`_rTxE zeZ2&lbe|8A;=UQ}N*Q~7|1ryRpm((yv9LVRBG2SEKlpJi59|~z@9&+-EDvnPmI2@) z7T)qoGR>lokkBd~me>4oaP9xN79B;G*+9Ug|V`x3-EclO3x`R7_ux(Z?ng%UaB&*XIx2!^`I?yT7$syMBir{o6P4aY$lno zC8PMC{>f~Q5@V8iE0#Bj?GxjZcd)$w@Sd@WAbr|=(agDJ70cr-Y%=2s`8=wpbA0}e zR-0+|c@LXj$|YK!be}gt^m$E>pObtb%Twd?CU{+`&;MSRREA|qGLMon<$n}ZAieIe zC_5?mw4DLV6D@K;!k+=jd|nIr2dLCop1lm~;m9~hzuHNbcU@YS{KG;M$f&76g0-oso#0?^YL+>(X(kgBQwuXQ!PLa0NMU;iYYS7;v24biaCTcsapRW#S|p~v z7iRwX&+aoVBjYE0cjE2QzjAILcD_TKw?|j>cYOFw!hoYKmpcX(v#4=r()1>O`**mr z^ih-N1tMoXnNsUqv`ybxrp@Nw|6$YYf>ImF@gtTSbfhD~>P*gn(YqenY#A98+VXPemtyoRl5F)6Xy>_04gwiHc>s2ZAo z*Pv$4F9jZT%vx<>+`8}fSY@rY=fSo-yZbHiINN=3!9#N&_Bb|c((T&k%Iy4k*6m|a zGZOz}O}#T9=30p?h4Q`=qC+?P%=fk#Lwqs$;dv*KFL-yT?}aX%gdth_XUQ`4mgW41 zCVr;EZF~0zi{C~r%F5sy=IQZ3gwL+@3}!Qs^r>oF2|b}s|RO2 zKil{8x?}h9tUs0g;k_KF^|y5n~3PdDJ^km4|<=Xtv=> z*B#yN>|fnEWc{QQWw*9GIH=L?kl0^Cvb|VbrAF+k6%(Q>N4`Gk-lWOV?X{l`SsCYE zFuu^#RTuW%{5rN(jF(^A&ZYelS9Fi*F?;-if&2Fz*%(Q(~V!9Tl6nwd$c4 z^A}A^81{18#v{Fcd$IVa+qrk`N_CzS?{dU_g!i6zW5)m7!+ZIfZSK+YR&HOiX4{@} zO=J6S8U8SF@SAR7ms%XC(SAv6@wPP&3|iVFx_4kJ`&kiJ`o}hMub!>Zu(vsdfxr3< z8c^ZzGkGQuGk(Ej&3@22+sXQk$h#{F@49r-nTB|5zj!*A=Z>q^Q+I5BvS-kU8D_0) zn&r*u+IPw6IvZjx9y>nSaqEK__f1ArTU}_&%IyyWvUaQd*V7YKcXYa*zt!cpeY}P> zY(4C_$u?8V7G||pIF>QD89Q-f!W{p;Q9h^oEg$uuowbo2T|>6~Gibl5rB@Gk-$p0Ab~Ks)-PUFMExHC@ zpO|lX)Z?vNUu0jr`k6_VDnFc^@N8^Ox2@;a40<#8j;Z;clkdJM>t6kM+|w(QpN(m6 zGzwCycKG1o4jbw!UrZJe_noMamRI@#~lV0dwy}ySyS^>-Z8)K>=ZWlT9^Gf zdxS-sS{`aWd)7}6t=v3sooF=cNrcX^#lxd^dFF13s8%>A;abFwnof5U*6a40<``Hy zTfpp#IXyiJzE1e=*Hc4AbPbp{rK&?>ndtak!E?8~DOaF+jYos7?s)y}#vomPo6ELm z%M7?auHMLMo$l=3TmE$uK`5SZ>x4`99)9W7!z#aF$ZOaX_jB4hugHq@g9{gYk64pPAYxQ`9FMDXpyp;-vRE+B zYhj)>t6<9d+dBxRna#{hO)_ONWgb{CF*PmXU|-nU)WU*1$=SMpWYX}km0I{e`Qkk6 zf+5?xnsk{ypZGGS((HR09(F{6rDfUsvWG2M#{I#yj-$NE!@irfg8iz_Hl%VZUSdmd zjq|Hst{ru0|DuBt#g3hO)aZ7jwf*NNoS9NPa@p(~FYavIQ0COb(3QdGpJs0yy{>Bb zKKDNdkCtG;97{O})U@ALmEHuJVK5#9Hm32J-(?D>K#^Zvf= zS)XB-rq|EXw%2x-hz2>H#M-%@4{o)x-;RAQAye&N&fn|q8T<0W`6=P&^M)2#AK%OE z((RgWa&76+%gViSW4q|sZOx9}j{Ylf%e{%ygI@h{?EIO8Ex|56k!OxB?YC;f{>!lu zRlT?DSbsaQZG?HymX$u?d&hkfadyZ%^Ap0cGvOn*-yd5BGXgOv!_j6q+H~(|4gGK; z*NfY_ZKp-({cv*1Xmo>+Ly|Gc<U#EUtaX|05=>N-;800A6~1?AoxfatdtFS2Y9qth?cq??h8KB6qzR5KtAt8pY{s9h z@wj%mbv?@s5d?=*-J~mIX4!sr?%B6TP>mefEIdQ~f_?o$UAlw>hx-MGyY%o0_6cBR z-;gf7d$05g5}g#^z`-f_vsxJt{@TS*CjkKBv>Ax-M=tYu0n|s9CwLi+kOQ?zJmds^I3~UfZ*r3`~PC+I+j$2oLS;=UI-< zq=8c!%QMU`JUlQsAWR-P*r$h|uS-OrUmv-~!ZR!+lrbs9*Uuq5vZr5lr?Bu)*1@Tq z+@oBwE}l|Nm!3gB!G0fj8NE*Og?fgB1rl>U@KRhi`C?(gK0U*_hJ=6M#kg*sJp#kJ z_yrMxA-$DLb?F@z9@4`lum{s8m$1NoelCGwE{M%bq)y$a;o9)6BNcIlmfWK zTgLkyKE!;#PEqHn*e5J3Fd&!_)We63AIM~=$7{*z48rPN zEW+*m7g59Lb?zGI>+2V6-~zI0iD>YEdRGbc^Y>$t>Ef4)3u(Yg*YYfw^*fd_sdF9m4#Aq*<=IldGIuDChp6%}MUf6qZegOePK_qUuhyf)}?hvy($eaCIk= zj*|nig%w05DVJwf7S1G!(by!~IW#b!YdBNZFqiPI%*MKg1o_Ic_74j233sYd-m{z* zkm?$tKE8pyp&@cF*Rrk^DoNy3tX!c|g(_^87Qs~g0?8?{`7ScqfJ%!3?O9F_bIBDj zMgf3hoOe)2ABk_3E4WqkcXh4k(#6fcyo+1;N?lw$Dpc@rsaVOc5_3#GoqgS1)4;a? zA0{NpNhI-!DuEE=txu?*k4uD4P;bmYhIx|&s_GvmawjlCi$kh5Rgd7_J!skt357Hm zBbfwUJYyGNol=LUdRPg~3Mryl zK{YBcK@Uwd)g9DmqEqV7R9{6xvto*9R@6WfJv7l&cTl5=PN_pveH95!w-nKI(?AnF zG|^OdP@{=XsY6qJ6$#BsDWX|P15NbML{r^CjV3y!4o&q{BsASqMAKaZP4v)2Q{6$0 zCOV}KP4!hIG%KfwW@QaD(L)nWbq6(?=#)A%)mM?w^hgm+4-GWYLlaGP2Q`}LlsYuk zSCP=Hk|LT_G|)s3O*GXV)M%np>d;KO$_M)OdLaRlTkq`VTe))u|B5dDKCZqlZk7Ez zyLh;|S9EdraIfN5#of2Ff5l2^aO**S{BF#9 zlvt~R>KqczZlRKaN!2Piw(wy$M!tb8XKPq}c;?yln^pbTt-pa@WS8=33shVwLh0+{&b; zhRIRvuUz{B6}XOHPsZC2e+U0SzaU>pmwh@{?EJs-z5^<%Bv>1>hzT*G0-|faFgeJG z!T`!DBB*OZaS}m+!6A!rUB!Tyv!bqITxC@hb6`yfDrUi)Frltu1kt~4oO|!wL2&oI zedqk{IqNuG^>uZ1cXf4jb&rs*QX^6=`1c|eL|IfS@KeRwAem68lJRx2pdT2^L3)iU z%*+T7zyM&DQw@SWL0F6dQH6tkS#tq(Bx!{-mT*-(f|k%m0_J+kV8cu+qH$n2#=au@ zhS8Cz7)A<;w~`w7f!I@MWLT)qfNMKQrjyHs>L3JyTT<8%2>6Iv%2$EqkV-THv52qH zNPj@v;Z!wTE6gjx-v77F=@T%eVyVc=** z5*bHhuq~od0BmbT1i4_}f`!?Pdn+&%=$@7!S48V0(2aCtBs%G7`&>7ryUar%mLW<$ zgz-djxd-CrCJ-V#frrw=(@o&ca}!V-QPy@%8Kw%4BqoDKEz_bf8om~T(ZXcFV6+;o zP9;$DR7MzLKWkQW)BQA94(Gukp%4^`)T1L5+gnRSItXw|#RyL<6Cxs=Muf=KS{GD>vQJ#=(9jC}w`Fi4gmR5&w>DXm*7pdbzvg^Ldc46~TxtK{(Ss}EKg zLZd^%Lp6kg#eA&@tTG~$$RLm)5kfnKf*?dIS83!jiCU`RtIKJuI#fk&F3IH&HKgbt zflwym%fv9}Q6frUJiu&#NE}NwP7*oxM<(M*OI)xELQaP81~L@r5F}*kmA?ovAR~X?BH>Q4t2g zD!Pr4iIgx@WFCl8By>YWpe#ftlk*Wzo>In>$vh=er5mLtmW}BhqjMghijFa;&;Yx0 z-mTrhvi46Lv&h! z99A)Cs$9quAzHCS%hO4~IpF`uz5-jaIejXg8F!Z;rZpeO2-ipGH6aFlIB5|Xrio2M zu~$+fy;L!91fYs=K;1N4GeQ}x4sw|Q5$eEI70G2XL@m>(5ure<6{)m5wMz9PgCLlw z33DHj5WQg>F&OBspeYg6FiQoq(B#Ym-xZh=nML6Ad=<`21e}P%_>OvE4`~d$D=>Eo zp`I6~tb+pVpJW-~kQosOF&M6yv6O*d5igBti;X~JHE3Im-!kAUVxVzl z7y)otSe`gfREQ&Na5l;6i9YQVFA17uQIXKrZ~x^OiF($RxW^vD^GmUK~UZ-a=da}tv9F;P0$ z;W4-141>TRAi3Baq`JVNO8}vwb)gYzIEPg@Q-mZZagGZo{zwoU4!~(y7@~qW1AH(r z213O$2g-x1NR`|wD-YG^uPIQ~U}G-Qpx2-WV8N>Ja23%Cy7l2EB;})X5gxI?Nr2B) zkyIjs<1f^B05r*g;)THhvC4qN=?!CmDb7r-EGirTB1u?Q2Q?)WQ8ApkO5K^NMTrd zC8mdQ(ndlyOC*{Z5vzkXL!tzJgig1%Y!VV03z(weOvtrLU@MHMh)qNChN1P*1+`SL zB*isu6cpBb7K=iKrL9#8#!?ZFL_rkRWQ;mNz=9|uWVBQym?tHQC{kD##&D<({hDmD zGl#een0Bx@R7MfzTL596inahqf20K_(!$tdjW`8<41i$ycVyGQ)3rq2668fjg;F+% z;WRNRNLUrO)dG7%mQa-73&N_%Fmm)Ej{1sJImtwr4KuTXR!TCExmm*@{zsNMIuKc77zbY>mJ2)}fG%;^Ff~T@6v4l~9qeFxq{GaZQAc86w`y0>QBU9Bt2Sm0W^$j*%w2)C3 z4JmQhpde#>kl%@}K4^|45=)(Z8^0ye=)hY*^GNYlcXz~HDA;h4%*3!l(?tn5f>9e9 z6a?Nn$w-|Xig|p~2nW_jNy7nGO0NukA3*bms07tw+xj-O=L_nTYT+xoAx0JK4N_3eHa)#;SkCGNU8<$J? zLYYLs6Uty1amZT{&8WaYK{`KM9VlSM#$^y3z`^!L5BpNJL1myim$j&H&5$T;!-;K@ z0D%;Nv7UavYlGlu0)jaRzSV?taSp$boSSB+Mx-8sG$BObl!TxLSw-}yfvE{Y`=3Cl z!XiUd2-i%jq)ODG(QwL&5Q{C@9P%y#9Me)-C5#o50X$@q=O0xJcSX>B^*>PwOE5fi zN(xu0{!zz-S4tx^@_(QYI!d|P;5i8^GRo+!Fr(KBBGHFgB}NJt+mGvq6Rli5RcNW? zg#8C&hjvS;5~||h`f*Khf&FtuaiLaNPqgt$bD@m3#TZ^EoG8LFlRgyjEoGAlkBRBt z@SMyzOawK>O}a-+c5105i;eWCGei)Rh6E}D=N>Jf$mm0fO%3im%`2i<=<7e51+9Qy zPBDRR!=lAq8~C20q1T2x76c3B6;#lNF$JRPpbN)U2c=L`LJEU)TG-N6&}SjpDLleO zVZo6e3QP|u^P)T287FK+Gs8+GmSSx zN-2S}oY6ef{`x*o`S6^oLE~6715PgOgkMDgax9Xj`r#llqaJR`@@gx0q(CFM5E=R` z7u=j`xKJ5Ghra$3H7KIsa0kx#A!0(+Svl+d&zt~q=^*-tS{HwGFhtiR`($=nWVJXG3GGUjifchy4@ zAodDJ*9mA8mUUE4EUFx2m$_l5r-nsBP)Xhxpu zI}Y1RbUS@n0FdO1@bf(cT2sHL^sNhS9;%qZq>2cQ z(nFqGq`9hS1m+kK^2nRJVj2QP$$*Lq(do!-Ia@(!ktuO`Dn&W4at50w4ARLo@Z<-# zj8ri<6UbezZYg#nAp=MssnQtVxggsJ))XB)L?IUg!f9A(Oeg^-<97rm>NF!Rxik^F z!rcv5^tcT_a08)95=P}%n1-cbqLEk;gBZ;dHJTUW&K5mkA}|<%F0|F<@ets!0J1iC zEZ^1mPevL8{bevl0prauOfb^jrBWPd`_TWy9`EoQT8TWVx zKw4v{{y%YfjW=cS^@8+M$+77q5lBU1xLYj{%cU}&9DL#Le}j(A@1DETYKD}U(Rl6* zSv|Sz((>ckh_pJsa|S`HiDONyNP|pipowf)Y8KK8j4dOk9!JAC$*EaKHM>0bn+EZ} z-9qdwH&)}6-2w(dx@}YdB>5Y30dA3z9;#?nKwtD~d4P|mpH3GR;16ClB+wi5Q2{b1 zUcf*+tE`<;r3uls3xK!z+QA)r*jz%=GU6`h3EkYKJf~>LtYIh~tG!Z+kBUTJ9sofY zIL3aW6wfwyaPttC`@4w{hA zFt{%grjI5JKB+vaAB|()xDVz?U4TJCDjt1A5Pg#olJyax2Wdr^>m1u6ndU-p0YZKu zTm~j?t}}u07#SrjDSr95WGXTUiVBQgf1}xsWq-=Oztq{-0 z<%~p?uR8SI&3_9EA0?(}m`_`2^^yCXe+y5g9S!-TU=twU;9r?#1Yod1m4GGalY;&e zLqlM~IWGE`1wDi9$0ja;hslRP#`wPtY&C`}8o=kTkd4sCME{Fu=(SmN-$km5bji(lt^Rr}$<>VCiutsm*KPWW{Hi?8W#z}>0{s$cSSfnPX-S+JcsYc04EGST_O$^ zZfu4F_&rnxF*hE=|N9;ugP0qS<^B+EAS{!qTzuo| zLtvBZ2Y4zRDln3li;A@ib@y1Htl7bI3a!0h)=AvZ z$Hyi#LYO#uW-&}CjUc3d$Kw6pckf6+jG`GQ2usN@6pUp?dhQn!pht)T8YT1IFge6f zQszqtFr;wDjF5otm*E8@DBUTezB7r6;&_-tT``4Y9P*F5Nrw~ zFD5x`XVAN`R4h7_d_ku&k8_zpqE!XKPI_m9TxhV!NI-jDiX3&cH>F^n!ivlM9Tu(Wep|a3e=qwy8dRyq>Ut0KVz-#OoNKlhM#f5V9X=P!Nv2o3C>~{)X34-{7$3usv zZFIp=djtyG9B)4yERr@JR8>#9PH=q8cS5`+(&D#I9-q80W<*)p(QhyGJ?8q{nDa5VuF!5?MA7M;EuIAm6v+NlkXST|0Z*tYllPhP_2B|beZ zTXny;;fzggPU6Bzr3nXmJRfdTc-6O$o$trj&duEpeTnvcTjV<7(1w@&lm1S7x}fOs zrr0yP4_R*0Yrg(=_{PHK@81r%a_#oKWKE-Qs@OY{yMZhAdXJp=^NP)LirbfdHCUZ~ z)br4n)~Y(cSscsAxfi0FTw|k!zNf|HUbStC{&;cNN?;L|SyaW!{?6G^f*$&!n~62u zM;)*qs(&A`=Jjjwokm&7#{wp21s%x^+L7fnKX-XrmTq>=%AA?Qm-O5>X8M`m*BxrK zGdj?5n$Z4qy+8yv~Wp{ORFEAzt!9_ z)g?P;evc=9+gj~EIBD?>fudmIdV_9K;fOC^a(f?ESS@LJW^ey3PC*GHo0K+7?@~2; zTeUBDrk!gsC;hnV{B26F8xIcqEV}jj<${dETl;+J_O$rJsKF!FWK6iBZ>!T>p4V{h z&0|PL+Z~#%VHZcOPkyKx@ciMM$PRX1-t99B*GjvuPEAc7d$Pp_hq&UFt_^MGl$|); z_-hN-Yb{+{{E@Njt&3~bX3qK;r0Kr6bML}0+i1Uami@eLSF15&bse|Q9@^A4cG!uW zvC4BF43Acq@|)b@|2kt!?CjOEXXLF;$*k_XE3fq8j`KU7)VMx-$TZi8L2j)x@24f6 z+Ld&=)Ma@_=ShQ|F0DQ@H(^t^t8WZj&L}n~?s_)5C%DO7^sm^Nd?IX{vASV_AR2WLc(vIB|J$QL*B}r?*9S zW;fdQ>~g`5(vjP87d0%MvPJk?yRISgIz8QTXYKL!{)z1lJKn47)cs*$vo7_9ExX%T zkh^~WuibW^sTyK`Hg|d4u2%QApK`kB->$~XSD_n4U2ne}64z)-8e{w7wh+aLT1+4c9?n0_tVr&T#Sy;`A0;Gg=TxV~e7;l>{4mucZQ zot}(5UOhZ+NcfG{H@3#*UzW5hDLfr}x>fr{MUG()?3(G1{d6U!`!8cvRUbV5qwS+H z&c|l{9G9Qpr{)&#XNhk;KFGrEF6xF{>2;&GKKSoDRWC(eUM=rXJ7)4@{ox^r)vDY& zT^%VpU414mbYnB!Mazr}Z#JaODJt2vDX#yH0+%F9KSf>J=Vkjw=#vwbkHc-Z-P@YD zc+I8pCmqkOjY>sdZxNUVD>)WkcrR#QKSaQMPOOtt<*%{qEZ* zPpN5tYO=-sZTy}qTdmD|)ViB$;2^QBp65Jnca;lgy(b9g2G45HYlchjy~)S2SE`an zAG>mOonZL#HbU{(#i54>XWrCIin7fcHCDieq4A2k%r9gxw?e(d388yrSF{po7W{iD(r?Fe3% z$zMO~!6CzoMw)qd(sOj1S~VGM)ncVzoaEW7v`^N}#`^G{pZc_9^2kMZI)6+VvUBC; z^z7As_6MFAvZtjk8ouyMZ$rJ#d+PSyD?8yG?l3i{UGq%WhyxoQyxDWHW~to!q_;sZ z@^J8~J2yVQXzQ^UNeOS6mQ(vpo#5$xx=bGb=gqdr>*HxxUs^xz=2%yF)X;NojVm8c z=UAT|KQF5!@kp5Elu3J6YsG0&nSB3#yY>Tp6El1TEp~mLI{tU3wr3|SJKO7hC+*d& ztk%C+w4RXa7~J;R&feP!JMOGer-N(sg2OGhfA)NF?DLjI`N*oIJ*ll9O;iM?=Z(D5 zuk)sDJ6h~^J$T-r zWYo>XYe(-!%x^f*spD?{Q}v&vU3AHu*Yc)Ub>~%`uI6>p)!Xr|P&{Vr_(Gc_t!<_# zqpBlAC%4M<$~`}5mBb4CnXTH3~~q+R6TJ<^;JbNPEy&iB1FDzoL#m&?!Ie7rUI z?WxWCYn_;>zrS_+FQYckDsUcmpu?GIf!)3HKZJ$Y+m_r<$Qxw2q}VC+QI}iW3j6d{ zHF_eG7R8=EyFa@|4?pe5#rd~==GXh&?YgGd5Lv!pyq|7F#-Q^xT1Jl1INUBdcWk1q z_4~zn$CIoN8+yI&ebQp4J96{7OJ3_U?a~vir}b<OaL~bdN1VGU)^>6k%R4jJcKwpa@v}NSURQVC#a#kR z@wwYGY;w|DtP$7i_bx@erDOK06^G()jT;=WWZz+{TfcW)@UrN!w)vMTuU9wn*Dfrb zlTqJk+RO=M9Y@*QKRmJEYOCQn?N*Nt@8eYMe*S`j$uZ#(a}cSrU9PZywVgwB26xZcX31CH-D}z1+q$lmSBG0!laCH< zw(;TmXPZ0k_g{LaMnIFa@#^ZK8D3RKu~O4(kv?p?hBcCioYDO09SdDv#zfT-+qw;ww!n>BX! z$KQLX+B~_cdoQc8H@eRGo3do@6AP_v?7XgptoVESvyd&NtVdlN#P-uN&U}pz38-^AOq6lV2S& zwml4Lc1SiTb`)}6d2U~-lYR;Rc1XXYAG>VpKCk~43q|cky36@_38SYBn7k-CeyIPT z-s?)r_7|mp9s6u=ir2&NPgaM#2cNTVUN$&z)}UzNf|`~Q86SUh`_MdVyiD-MyZzY* z)-RfUal5taa6hXHRx5^%sJ`pw)Jd-Vr;?F1^Ie`L&5TYt(mwu#<5iz|1FDQ|bYnwM z`sqOvB6{+F>O3l|Z0KL@-nlN!T7S|#x5wfW^H;W9U3HA*&yQX`f9|$p=C3i9jXR{2 zcDH@kMl$0@y=E?H&$D!ixwB6BTy`3=G{+{cZQtX|z8=yqkL{ZCmy=@j%Ej-CMhwZZ zd337y{i49zzck-cz1iqz6K_3y^0jv1lh3Iy(-$=TDLF1cbJ{g2scDZHO-BB;yW!4H zp2usZo)=!5D6N64-kfr7)cu5s&)bC8Jd?5h<6FPY?-Sn2I)$W{UfyUkeP-ISC+FXU zFWGe7CwWusByF9AvCZzDJ$o-9rpW8@?Iok*9{XEIB-Vfba^N3@XSNQt?bfl&?&Qu* z_D8ArhhJ%PWvqWf#PX00i(6iw@VbAhuip}u+H_kp zI4}0fpcfZUyl7l%pU}8uRNic7Us>*?xLXUJ4jn$E#+Dngfn|XX_6`0HSUX`z<9C}* zPW&*--tJxf1>u*5ci5pk-*ntmS@?>1HGHc#zn+>iM%P!FDvGk5d$UQ*gXB%`|Gbeo zF4Wegpr7~A>&0(F^7q9oXse9>c}2l9+twFiSN76X8=U;yS)ZD!E+) zu)dyQOB(4nt^IuNW#@*~rAH@yYw1^$? zbJF*x`yB{W4*XW!wC@A^R`-q-cR%pXRvMXa@7M9Zu#V@WYv-EOe-%*ma&d7;aPRCa z%ix*2qCPyIawYTGF*}=Fw=21aLdSGzP;-Sa&NU_ONvlrl`{Zo#+9Nx7B;G5prN@q% z5gEcZ#c!&4-dNZ3Q_@2J`aZvl<_C2%EMGd;HGA?`O~U5^Uw4?-`Ol9JtZJRp zu)&~5KKE=At2rF)oR(1XaAsig_D)d~*9mO2;UDsM)cC3{S@+^Xqp&fbXAe61?!9l$ z;vRVoaxycMJ|rdU{Fi2LFjxpa_gdp`ux@hpvh{%AVGdQkG~Zz1V)bs%$7@z+uU|bB zU*hlXv*x1nTAQ~0_t_tq_HmShN5RzVS4AJ>qXN@MOs{^fc`M!2c-LnKeEO^!^61)- zPqJGz{Q@)6yH_t!f8D$KWZ8&=FUKUm%ska*#l5|M>f1_x5nW%?z%ufWZ<=$<@7?V; zNn-!aI`Px6^M`NpSB)utmv**+-RA}SuIt{U*<=OUKiM|%)yI-=bz2S}F`>$#n)esq z^*OiZC$APKa+7@qUikX@=W(^>#@DJ@^jAO!#~Y_!Ki_rX%7YV^CsfHVspeZ6RrF2I zUqAj^i?!W$TAcjkH(2mZIp)~CuloWL`~I5NK^E;Y?6=d1+s0WJC$&8I-Z`Z#&<7dk z5St&kCA;RDKWB8^e6U-5S@(Ni-|15CcP-Ap`Q>e?^}6^+;t76l%P!l*m;D~=(D94I zpGDFs4mb4Gt31`$J=O5;iE2}As$N((%K4DPx2K_sQ`%3uRnre;pPKt%&HM`wKBiAT xqwi7e$k9n<{-1KrXcB7!#M6YJ`8n1AwTs-`s5jgBvpI~VK5e5*gteV4Qe zx`86`wl!^~V>4`?ZxnaiJW-fJsi~Hv5#zNR*M3{f|INkxcCLSmUEmHRwzj{=4@+Ti zHhrVx!E~jCXXEyflMC<&_HnM|)kpE>*DZcbi&}UDxA)V9k2MD4QeD{$1KwZ*y=mP% zOT{n%#(+))*?Cs`j+Wkt_ngSysJZB$l;Xh8HC(@_#o<0~%p#rc9K&K2_`Q$-Ha|YZ zeBQh@iTy0sDbZBW{Ghq9IX3;QlMJv*-XvWm2^u!=a_1$9tB+yE%68Ncc5MvuDgk1 zZ8)}Yj^_K!vF>jtgo>}b3Bb6O8Vci8;hk6*$>P>K$ryfrOLRb@6}F34e2B@lTV7n? z>rj(;VN)h#wcX4dYn?N2+CBd{3_=P;pq#I?eub_JSM^+-_}iM-uv>>EY(u&R<+8PU|8&WOl*wY(;3XKqQI*4CrruLW+r%Hodn32Cuy46|U`LOu9g9k+|my$*Hy;u=-MpSUz!HWm9T#p8Z{ ztV#;xqzZ+$d)imE@G-P(1$@7E&4X$(KQhBk*%k~LsYNlj#Z%}c~!>~=Z7bz_HxqA9(k@02Fs(hVfTDM2@McS<$NMUtTUAMaBjgY8hBq$za#`ij9G!boE7E1D z6lRU&X*$^mp&zdL5U@?9e)ie&?nhhc|L?%Y1ptf)&&?qEj zKS0eIu7=(O{$PSi{b2V3t&0_u;KNeowtp%!mrBgODoNgfEHxh5GW;P4UT8TWb>+c4 z1^!Ta9OGY&*xNu&zz52dr3NBU`{MnOJi1N+`c()7Kpz9kP_m2@Q_)8)WBwUO$u0tx z5T&4mqf4aK-;+kY&^SeW=UQn3U)`b38d(f(R&yfSK6n0MG^*e0aQELA=2mz0-9@T2 zEc&}8;`&vpUNnb1_Y(74|31lAC8u%HSpSzw#ON;s;EbF|w69qI0*_x6ny zM4jDOGG52lxX1H6)2{N$GUW;yW)S2Olt1rNo{$AVD{*e()dMlsfu1SLnV0 zd}a9}Q0rgXC`EQxY3>nT8knkN_j)aGzx|ItCYqFIZU(JN5P$ued{Mpv16pNJ=|3bC zhL1tU%rY5iHRw=Gf@eG^{E1t9I`_A+1t zBLq;micj)+eob1Y>P5nZ0lD#LmRoh{bfk&gRP^R4YacP62^DMoBNDb9f6@}*#?YZ; z^V;F`WVpK`Ao>tTo*Fdzlia?xP|zzc>spit*;{(LQtK>njmhq0jJt5lY{wPFoy zx*r|6`wKeuw9KnKkq&0YYg$n>P1hl)y zqkb@Og#FIKeyT9+1H^}kaEL}^Lg^kV`@x@Ns0e2n7((lZ7i)wQM}Z|IWmzjhBa90{ zztf2$^B$bAKKgP%N=8~YnPpEYq!TYek=>Xy82m&xx$zffO6C3 zG(nJj33YmLjt6z&iDtd70kz0M+s00vVTlC~VK@Tt6U#IJZYyeVxBucYK$Sq^YYyxV z?kt0m9d#qWX0nT3l`aT`5DZkfCFqLfUSS{&<9&b&*qU9j5yKDX0d-Tw@0PA#%cmUR-bOI2+m!#=KNNEga0}EnsiaoKa zpB@yseU>6DX#{3jFyaNo;GFcCyA&@d$``bjKtKIr((1JUpd}&_w-E%Es5nHSStL`h ztOU3oB$L+BC`W;4f&g^}aaN6+%EtUj8b!%#pbC_W0o7k>^)a|Ts0ZoVX-|Nk<&$xU z?Besm7STZePNY-(Cf6Jcbr3B;e`Dh@EU^Jik18~G+A~uI6eANOuK(E+v}z(*rTQZv zxrtAnU>u*H{5*W<1eVAjwNLs|sIfJ?qev@y)87{T*lQDrr}_Iyf%Af4{e$MUUKb&vjS4rXQi2o^yD zt`6J@Ubp_;KTbA|Nnw&;=&ZU;O;}C1`}l>t$h?{$GfXc>5MfbI>D_x&gU^QZsDX#m@NyP$zq_8%UV|KBR- zFO-WOIX~IMpnuqa&Js5ChT{lFNKPRMQXjD~Vb&6R?L~lv{pm^sxKn#MuNi);vxqpP|cD*UGQ8z`Y+c@^sb5qensYqQOF71Sd*9pa`a7I}3%>KJ5_4@3uCEiTcr?^Mp+u>?+8 zr$Ai91;2)Jc}>xSYgX@zUH7eoz*R8}0B}K9lNFfO%aeQ`Ya5Fk^*ov9B^RbUGb;#) z+R%aJzLHQJrQNYCcoFaF?z2Uv+QNsymZs&UazyEK2DVWJgVsU-zY@9&>kF%Xv`x%7 z$*e4i>!>f(i74~c_`X2?Qf2!TFT-}xjXB<)$GfRtywV$hDX3ALqwRGwNkZw9{CZ4Y ztRvmeB2&~y6nhtXCA>ZKMPzi6jZ1wOJ~=u;_Vs6%N+i4@#h4X;NXCpAZ_O_WBkcl) zD8aX4WYL*N_xfDlxI1CXz%e~vKT1$dRr#uD$?!_by*!^YvESQpeuNGWUT{-KB8ul7 z@e-$XvXh;zmj{MSjK!dovqo39a;}Na9_#UChX;`jPL<8=G1EQlTRB44zL3hAX}c2B&&MNddloxUEUELYdPK}Lk3vy6ShNCr?# z(JI?3wBNGa?$DsTzqq$$-qKRUTv8%S*WACUqcUGo@QOMhBJj}t(DHb*6^D#P!oB^i zY}SWMwrFT~R-Vv}=**k{9-=)EyaPAizRE3rQiuP75G=J*KM=A-j&2a$_Zr9u%0*+knIs-*pfKwoKwXU7? z`=i_Sy@h{>n@RC1$KxrC0{MH9Gd2nxm3;!B|HjhcWN0?GajKMTq#ru-4 zWV`1sWw(P+dw)&)+J%CyI7X(?L6bWy-{aNQVS$s;H*6--%pP~kP1ZS*>O?$>z3b~Qr7ZN4IV;iD>t~_n^Rgw%J3mgdBS%fS zYZH_0;QxshRo0wX)={6^mnAHm>*Y`*`l)k~#$a17rqa?j_`j-m`b5&4(X*ss-C^if z=wvLo{CJWRQH_1D$Kd{z^@2{_(Rn{Uyh#u)6@T;US2dsOgwCYQ)+qCu0_D-5Z1&ue0HRs@(>xvIGT!$l$SyDVFyouIhL@wY9n`_-{Sgn@3KSMIm6Y(TkBgG6^qC3^SE1@Ey{ll%e|~l9D^~0)qVXN zo#}(Jmo)p;H8yw*_m{hNdHdkrjn`CC?&L6VKc}CU{iSk8iUlEd&c386$iaq|%#2)F z=R0pC!w1qORq+?t>vx$wG+0NoO5S##JtX4EuululS&wH|Q7A=I_JNhF(v4*J@z`ox z&sM>weWcSKwpve%YK{%s%@>C053R6}9E*RqxszkBlpVT5W{5WBAm8&r$cktNW3KHl z`G?oAjF|M}PEPhR5j2k6Al|k4)LCHNd%eE^EzV}DD@>20AgO9)dbab=hxRm9a$&D2ce8OIJ&b}p_<8Eg&dm>Zy_r-?V zwUk)e4lpaPkTlPSi@gCV(4tg}GA>O!k8gM?M;7I>y$s01Gz?whQu*BatMWT{yQBx_ zUtkzJ*@V9#X}T6hG@stbIN$73+2^K*wi#C^FfGvgQGM8OSegv3ZeK}G89AWpVLgx0 z-0hqcCuj)oO-QfbVj4+D)Lqu7o+5=MC|-J35$URyr{~l?pW=L%*UI#7EY&a}NzZYk zS#CqTNWWd0E9A&&p$=^A68)d69bYc~5;WtAkt65$;;Qi#V}Yb|@g9Y~pJ&R&Y4+OfjuGFKtWE zb(^xsMencX`!$u1NPR~RlHW6rf5o{Mw%yA%C);Y#_l(4Y`Mi@k_4cM%bbX?FNewHl z@H|5p#TY{lSsD%QFL{q<0_aZO-qX5l1Fft1Jw4kWSDzitEmkX_(%gMqj%4`&g!?5=G-WJRChD>88F zHbAUBxvRAcFr=Sil554^N10E*b5fP7Y_=urkXft1Js?dTr0~%nz)+ozD$7b;srr#& zJs06)oS&-M*lv_9^BF!kZToKg#!U}n1+vn8 zjCXXcF2*WbP*pz;>s2;`=V~6elML8m>}ICz=jLi|O5VsIY(U8yan}Z&FBqJhXGgEL zFWn&Oym4Q2sYJAA-Dgrq=E7;WYYG7H& zgy&FiYrw0O9-s$h&4nwCYsC|M+~4N*{{$t0*GBmLLG5+E6F)Rl1jg3Sg+*)3xpOXY zGC1xNAB2GU0hE!g)=-~ZIgO zC*LuSYst!gr9C|%Ndu*fr4K#K^YraHqeof3qf35gr^d@g-ptVbDGF_owj;D_QAeRE zr-%^GOI&N58WUe2%Yj$1cMQCf2Q=bjCKsk{-tv0SzGV8mVtCvdb9t#>VIS^Q`D8Gs zr?ZulVO2J$$m}U#k~$+#pQ~9;eTtMW-c~2p#xqd!u{Vw!vL|Cll%E&pRn1%{%{bOG zb*3k_=J{;{A0c*z-@gO~rQR2epewaX7dUjd49~Z=rqe2~drEdzQa0yEpHa)Ftfnr9 zp$U+e)*-3b>iCCyLFi30xcRXf^J%-PuIqk#6VtuI{gZHWZwtKjtQ@1?=uF-frqZ4h zU2Xr1a*ZGKy#`Q55Dsax>D^cM!MaVp5WZjGT7l}eKYaF2*g+t_!rSz^ogA{j|Zo?RB2~X_I9V4 zIU$0*?JXtevcbHT!kuQ4#Ar0?QdB(ggR`3vEjoCYGcH-}((o}g%EfNGUEw1^e*HX0 zW6>JF*~fB4%A6km;NXBddDfO}jGa8R>c%>|%edj_@wsp#nH#%bj25pF3+nwnK=|P{ zT6+x_uJEN!g6r^m4*QEQJFZ^)Vt3M|Hi^AW%U1%GXyn>56sXY=U!>mPY@FS)*dsyO z?b}NRh*lZRUOaVYB@ew`<^8uGt7V@!LiX`}#Wv`T@2r-Ky~$J&T!z<%!mk(7qZK9Z z#IJpW3p?I;n8_}pZIw+H@0jb~m~P=_ZvCjfCKY~6&^6r>UYXMPprfWQGJ3&V*{{L* z(nr}IVTeKmY01JHtL7X*d5t(0D>b)yVv5NysE!DE>n`k49nNkj3J}`w*{XWhRI5F% z-uqLU_R*Hp!W$`++hM$@fM7xo-RF=n3A&+#=mV$dAGXp!$SurbZ9u4SmzxklSSYm0 zVpdoAaf;AvYW>LUBjf#9-HhpsL6qYSFg_Gf=6lq#gtX4z@~P^$&XtWDqBM=dY; zdn1U+#owLO9=mjmn^k{z$AY~ARld1bM`NeO`nId1QA0E%^KH(318_H&!f&c@o7fo@ z3f>kOFODo%CU@e6i4=+*aZ6fT_vX$#qmxl&L+i4Eg7!Qo%c#5I4)#Zz&+GQSU3{0# z;5oW1Pe)%6+_-AL*LSPn5!Ghe(d0oN|MPLGx;G!kI$mk_6(iO`glm`0IdB|LKa6{m&}bJ2(uJY;t7zYSevD0sG~{MH zn?68MaFruH>zG!{{GF%XQOHoXX>cQi{l1&UN5 O;SZV|-j{ELyZCPem*Q~% diff --git a/deps/eigen b/deps/eigen index 5226566a..2265242a 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 5226566a14ddb4d84214c40809531038f087d187 +Subproject commit 2265242aa121742dd7e80a0167228b43e95bec62 diff --git a/examples/exporter.ghx b/examples/exporter.ghx new file mode 100644 index 00000000..983270d9 --- /dev/null +++ b/examples/exporter.ghx @@ -0,0 +1,965 @@ + + + + + + + + 0 + 2 + 2 + + + + + + + 1 + 0 + 8 + + + + + + 6d414e49-3182-4495-b3f1-09564af81365 + Shaded + 1 + + 100;102;0;255 + + + 100;0;150;0 + + + + + + 638485274587794356 + + false + exporter.ghx + + + + + 0 + + + + + + 84 + 292 + + 1.2750001 + + + + + 0 + + + + + + + 0 + + + + + 2 + + + + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.6.24101.5001 + + + + + RhinoCodePluginGH, Version=8.6.24101.5001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.6.24101.5001 + + 066d0a87-236f-4eae-a0f4-9e42f5327962 + RhinoCodePluginGH + + + + + + + + 9 + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + + true + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 710c15eb-570f-4237-9cb8-afdde0961b0a + true + false + true + DFXMLExporter + XMLout + 1 + + false + false + false + + + + + + 183 + 45 + 171 + 84 + + + 290 + 87 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + d48261d1-1866-4c21-a3eb-a7e98ef7a2f8 + i_dump + i_dump + true + 0 + true + 8c08df72-4af6-478d-b73d-4cb5062e929c + 1 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 185 + 47 + 90 + 20 + + + 231.5 + 57 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA7xJREFUSEvVVUssnGEUHcRExPvNeBvvV7xf8Yh3YiFBlO4kbCS2No3Gqlg0BBuxYEeINGxs2AgLiVZiJSzstJW0upjpQ01O77nz/0Jpq6umJ7mZ3/zmnHvPvff7LP8Kdg8Pj8/yib+IJxKPg4+Pz+v5+Xns7e1hZ2cH29vb2NzcxNraGhYXFzExMYH+/n60tbWhqqoKqampkITeyk+tbobfwMvLq11++H1hYQFlZWUapaWlKC4uRmFhIfLz85GTk4OMjAwlTkpKQlZWFvz8/Byenp7PDJpfwhoYGPhhaWkJnZ2dmh2jsrIS7e3tMHFycqKkaWlpSElJ0UhOToYIOIXD5qZ6AN7e3i/6+vquR0dHUV1djdraWg0+z83NweVyGRJAc3Mz0tPTlTwxMVErkeS+iVWvDLp7sEdFRX2dnp5GQ0ODEtfX12vw+ezsDCsrKwY9MDk5qTbZ7XYViIuLQ2xsLHvBKorclLcg3u90dHSgt7dXbbktMDAwgOPj4zs2HR0d3REgeXR0NIKDg10i8sagvUFbWFjYl+7ubm0qPb9t0fLyMqamprTZp6enhgRQV1d3YxEFxAHEx8dDptAhnE/d1NJYyf5deXk5GJwWU4SVUOji4gItLS36bnZ21qAHxsbGVCAhIQE2mw2RkZEqQkGp4qNw+1mk889DQ0O/kJwjyFEkEbOl0NDQkO6COaZdXV0GPXBwcKDNpf8xMTGIiIhASEiIisozF/WlRZQ+ZWZm6mwzKFJQUICioiKNjY0NDA8P63fmDpyfnxsS0EpN/8PDw9kDFcrLy+N2f6LASxkvZ25uLkwhPpOMFTgcDoPqYYyMjGj2tEecQFBQkPJIVe4K6BP9YqmcCgaXKDs7WzNfXV3VZ37Hd1yunp4egx7Y399X35k97WEltFf66u6BgadWq9XBH3P9+cklOjw8xODgoD6b7+gvR/Py8lIFrq+vtVoze1YtFnEXbqZIwdmld1x5koyPjysBBfg3g1WaS7W7u6vviZmZGSWncElJiUvo7u0BUcqzhARcIhNOp1OPCY4iidmj9fV1XF1dGf/hxtbWFpqamhAQEEDv728yIVW8Eh+/MVtOxu3gnLOZ9JgNpeemLUKqIyyTcyU0vzyLCBuroN/Mls0zg6S00CRmQ2X64O/vr+95N0gff3+aGngms+zk5MjxcRMmKefczFruAPj6+up5JVWT/I/3AWEVq95zLCsqKlBTU6ME9Le1tVUz5aHHg5FbzfOrsbHx8TeaAd6vP9+5f4rH38n/ESyWH1B2wifz0XRNAAAAAElFTkSuQmCC + + 9808dcd4-0a56-4762-9ba9-bb0923820f02 + i_assembly_name + i_assembly_name + true + 0 + true + 642efa41-dbbd-47ee-a53e-e1f51ffa1f12 + 1 + The name of the assembly to export. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 185 + 67 + 90 + 20 + + + 231.5 + 77 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA7xJREFUSEvVVUssnGEUHcRExPvNeBvvV7xf8Yh3YiFBlO4kbCS2No3Gqlg0BBuxYEeINGxs2AgLiVZiJSzstJW0upjpQ01O77nz/0Jpq6umJ7mZ3/zmnHvPvff7LP8Kdg8Pj8/yib+IJxKPg4+Pz+v5+Xns7e1hZ2cH29vb2NzcxNraGhYXFzExMYH+/n60tbWhqqoKqampkITeyk+tbobfwMvLq11++H1hYQFlZWUapaWlKC4uRmFhIfLz85GTk4OMjAwlTkpKQlZWFvz8/Byenp7PDJpfwhoYGPhhaWkJnZ2dmh2jsrIS7e3tMHFycqKkaWlpSElJ0UhOToYIOIXD5qZ6AN7e3i/6+vquR0dHUV1djdraWg0+z83NweVyGRJAc3Mz0tPTlTwxMVErkeS+iVWvDLp7sEdFRX2dnp5GQ0ODEtfX12vw+ezsDCsrKwY9MDk5qTbZ7XYViIuLQ2xsLHvBKorclLcg3u90dHSgt7dXbbktMDAwgOPj4zs2HR0d3REgeXR0NIKDg10i8sagvUFbWFjYl+7ubm0qPb9t0fLyMqamprTZp6enhgRQV1d3YxEFxAHEx8dDptAhnE/d1NJYyf5deXk5GJwWU4SVUOji4gItLS36bnZ21qAHxsbGVCAhIQE2mw2RkZEqQkGp4qNw+1mk889DQ0O/kJwjyFEkEbOl0NDQkO6COaZdXV0GPXBwcKDNpf8xMTGIiIhASEiIisozF/WlRZQ+ZWZm6mwzKFJQUICioiKNjY0NDA8P63fmDpyfnxsS0EpN/8PDw9kDFcrLy+N2f6LASxkvZ25uLkwhPpOMFTgcDoPqYYyMjGj2tEecQFBQkPJIVe4K6BP9YqmcCgaXKDs7WzNfXV3VZ37Hd1yunp4egx7Y399X35k97WEltFf66u6BgadWq9XBH3P9+cklOjw8xODgoD6b7+gvR/Py8lIFrq+vtVoze1YtFnEXbqZIwdmld1x5koyPjysBBfg3g1WaS7W7u6vviZmZGSWncElJiUvo7u0BUcqzhARcIhNOp1OPCY4iidmj9fV1XF1dGf/hxtbWFpqamhAQEEDv728yIVW8Eh+/MVtOxu3gnLOZ9JgNpeemLUKqIyyTcyU0vzyLCBuroN/Mls0zg6S00CRmQ2X64O/vr+95N0gff3+aGngms+zk5MjxcRMmKefczFruAPj6+up5JVWT/I/3AWEVq95zLCsqKlBTU6ME9Le1tVUz5aHHg5FbzfOrsbHx8TeaAd6vP9+5f4rH38n/ESyWH1B2wifz0XRNAAAAAElFTkSuQmCC + + d8eb4d09-c5ce-4358-a4dc-869a7ee7fed5 + i_export_dir + i_export_dir + true + 0 + true + db74a3b5-1227-46f8-823f-2e8caadc27f9 + 1 + The directors where to export the xml file. + 3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88 + + + + + + 185 + 87 + 90 + 20 + + + 231.5 + 97 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== + + ff511bf7-48db-498c-85b4-744eab811099 + i_breps + i_breps + true + 1 + true + 09820e90-22d3-463f-aeb1-e7a483ab60c9 + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 185 + 107 + 90 + 20 + + + 231.5 + 117 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 96834ab2-ec04-4d8b-bd36-310f89a199da + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 305 + 47 + 47 + 26 + + + 328.5 + 60.333332 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + a7380c0c-e690-4b7b-8b20-d2dd6945e4da + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 305 + 73 + 47 + 27 + + + 328.5 + 87 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 21a275d0-1f72-48ed-97d7-b2d5bae06a84 + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 305 + 100 + 47 + 26 + + + 328.5 + 113.666664 + + + + + + + + + + false + IyEgcHl0aG9uMwojIHJlcXVpcmVtZW50czogZGlmZkNoZWNrCgppbXBvcnQgU3lzdGVtCmltcG9ydCB0eXBpbmcKCmltcG9ydCBSaGlubwppbXBvcnQgUmhpbm8uR2VvbWV0cnkgYXMgcmcKCmZyb20gZ2hweXRob25saWIuY29tcG9uZW50YmFzZSBpbXBvcnQgZXhlY3V0aW5nY29tcG9uZW50IGFzIGNvbXBvbmVudAoKZnJvbSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcyBpbXBvcnQgREZWZXJ0ZXgsIERGRmFjZSwgREZCZWFtLCBERkFzc2VtYmx5CmltcG9ydCBkaWZmQ2hlY2suZGZfdHJhbnNmb3JtYXRpb25zCmltcG9ydCBkaWZmQ2hlY2suZGZfam9pbnRfZGV0ZWN0b3IKaW1wb3J0IGRpZmZDaGVjay5kZl91dGlsCgoKY2xhc3MgREZYTUxFeHBvcnRlcihjb21wb25lbnQpOgogICAgZGVmIFJ1blNjcmlwdChzZWxmLAogICAgICAgICAgICBpX2R1bXA6IGJvb2wsCiAgICAgICAgICAgIGlfYXNzZW1ibHlfbmFtZTogc3RyLAogICAgICAgICAgICBpX2V4cG9ydF9kaXI6IHN0ciwKICAgICAgICAgICAgaV9icmVwczogU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuSUxpc3RbUmhpbm8uR2VvbWV0cnkuQnJlcF0pOgogICAgICAgICIiIgogICAgICAgICAgICBUaGlzIHJlYWQgYnJlcHMgZnJvbSBSaGlubywgY29udmVydHMgdGhlbSB0byBERkJlYW1zIGFuZCBERkFzc2VtYmxpZXMsIGFuZCBleHBvcnRzIHRoZW0gdG8gWE1MLgogICAgICAgICAgICAKICAgICAgICAgICAgOnBhcmFtIGlfZHVtcDogd2hldGhlciB0byBkdW1wIHRoZSB4bWwKICAgICAgICAgICAgOnBhcmFtIGlfZXhwb3J0X2RpcjogZGlyZWN0b3J5IHRvIGV4cG9ydCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2JyZXBzOiBsaXN0IG9mIGJyZXBzCiAgICAgICAgIiIiCiAgICAgICAgIyBiZWFtcwogICAgICAgIGJlYW1zIDogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sIDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICAgICAgaWYgaV9kdW1wOgogICAgICAgICAgICBhc3NlbWJseTEuZHVtcCh4bWwsIGlfZXhwb3J0X2RpcikKICAgICAgICBvX3htbCA9IHhtbAoKICAgICAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgICAgICBvX2pvaW50cyA9IFtqZi50b19icmVwKCkgZm9yIGpmIGluIGFzc2VtYmx5MS5hbGxfam9pbnRfZmFjZXNdCiAgICAgICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10KCiAgICAgICAgcmV0dXJuIG9feG1sLCBvX2pvaW50cywgb19zaWRlcw== + S + + + + + *.*.python + 3.* + + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + 09820e90-22d3-463f-aeb1-e7a483ab60c9 + Brep + Brep + false + 0 + + + + + + 108 + 107 + 50 + 24 + + + 133.63321 + 119.357155 + + + + + + 1 + + + + + 6 + {0} + + + + + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 + + + + + aa56315b-2905-4049-8c41-0cc8b39d864b + + + + + 322f4e22-d195-435e-b290-052cb2318277 + + + + + 7fc04154-255a-413f-a8a1-6ea034e1e779 + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + aeae5255-2a74-4040-9e44-e3aedf934485 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 8c08df72-4af6-478d-b73d-4cb5062e929c + Button + dump! + false + 0 + + + + + + 53 + 46 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + db74a3b5-1227-46f8-823f-2e8caadc27f9 + File Path + Path + false + 0 + + + + + + 108 + 87 + 50 + 24 + + + 133.05814 + 99.121376 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 642efa41-dbbd-47ee-a53e-e1f51ffa1f12 + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 55 + 69 + 102 + 20 + + 0 + 0 + 0 + + 55.337097 + 69.41688 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 4646fc38-6159-4526-ae07-13f7dc4d54c6 + Custom Preview + Preview + + + + + + + 479 + 45 + 48 + 44 + + + 513 + 67 + + + + + + Geometry to preview + true + 086a1d3d-246b-49f6-a9b4-24689cf3e1fc + Geometry + G + false + a7380c0c-e690-4b7b-8b20-d2dd6945e4da + 1 + + + + + + 481 + 47 + 17 + 20 + + + 491 + 57 + + + + + + + + The material override + 3131a412-8e5e-44ab-883a-eaf4d47610d8 + Material + M + false + 4ab4fffe-a939-495b-828b-02fd527f45db + 1 + + + + + + 481 + 67 + 17 + 20 + + + 491 + 77 + + + + + + 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 + aa8c3345-4c0f-4f8d-a8da-af99adc98f83 + Custom Preview + Preview + + + + + + + 480 + 92 + 48 + 44 + + + 514 + 114 + + + + + + Geometry to preview + true + 15b754a7-39d2-46c6-ab6a-283c1e8ca0c6 + Geometry + G + false + 21a275d0-1f72-48ed-97d7-b2d5bae06a84 + 1 + + + + + + 482 + 94 + 17 + 20 + + + 492 + 104 + + + + + + + + The material override + 4a3b2a65-efde-445a-b243-524560892e32 + Material + M + false + d8ed0f8f-5311-4c4b-ae32-f035c085b9d5 + 1 + + + + + + 482 + 114 + 17 + 20 + + + 492 + 124 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 4ab4fffe-a939-495b-828b-02fd527f45db + Colour Swatch + Swatch + false + 0 + + 255;128;0;255 + + + + + + + 378 + 69 + 88 + 20 + + + 378.22855 + 69.73081 + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + d8ed0f8f-5311-4c4b-ae32-f035c085b9d5 + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 379 + 116 + 88 + 20 + + + 379.59103 + 116.77558 + + + + + + + + + + + + + + + iVBORw0KGgoAAAANSUhEUgAAAOEAAACWCAIAAACn9nhUAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAABQkSURBVHhe7Zt5UNvnmcfZP3Yn/Xfbme1Mmp10ttvZncxsm3ZmG7dpuu1OszPNH9uuJ906WTtNnPgGHGNsDmMOcQiJQ6ALhEAS6ADEfRpsQAJxCt3iFEgIkJA47N0mTurpdNmvJOI42GS6ranfjJ/PPH79/k7phz6/531e/SCOIL4A7BIEq3zq6BpBsAc5SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrAOOUqwDjlKsA45SrDOIToa/JMJBAJ753oArA+FNv7MrK+v77384wPn3Dv7AeBK93Z9ujkUR2OfqNvtdrlcaB4ZYHZ2Zhb/DgCH+3y+fZpiEZvM5qnpPx9mq9W6urr6eDXF2XB1lig4/8NgvcPhOIx74wvHoTiKBDA5OTU5OW212m02JwIdq9URi+iiw253GQzDKpVKo9FqHoG2tra2oaFxc3Mz8MnnhA8Mjo6Ojs/OLrrd858TMzMLsZib8zy4iHhwt8+NvT3xWlNTFqiKxBZ7G386MH5rawt3KTQNhULb29sbG/h/Y2cnvL0djoELX1lZsdlsjxxMnioOy9GBgaHJSZfVOj8yYh4bs6EzMeEwm93T0zPDw+apKZfT6ens7G9vbx8aGhp4FEajMT+/QK2uw6cVsxSdep1Oq9VPTc2YTNaDYnTUZjBMjYxYjEZzb69xfNyJjtE4jTUIk8m2b3/E2JgDgU3YeWLCNTHhjC5GNuFst26NTkxM7uzswK3o9f2/wfuPRQzobrXapFLpnTt3ICtSZnRg37TZV1wuv88HOVew28IC7hM3OXoojobDoc7OHpmsQSisPXPmUnJy9tWrOefOJSckpJw/n3zlSjY2KZVtPJ4kISEh8WA4nPz4hMTxSafPv7nsC9mcnrNnzzXUt6nVXXV1HQdFfX0vlyvGS1y7xsWrZ2eXJCamXr6ciTfA4Qh0up59++NsMll9RYUOfalUIxDUlJXV8PkVn7xKp0bTmZ5+bWJiHOlt7wr/MCJeRrLm2op/3esLLHkDi8tBRGjzbm5+UUlJMU44Pj4ul8udzomOjuUf/Xj12LF1h8W1vDDT29NtMpnsdjtVpYfkaLi5ub2srLa8XJWVVYzIyOAVFcmuXStMSEjl8yslEq1c3pyVVfSd73znW9/6pxdf/Pa++Pa3v4V4/fVficXi9fXg6loABSEmSyKRUCisqq+/oVZ3HhRabY9UqubxpPAMweXiGKVIVHvpUoZYXKvVdu/bH05nZvIzMgrl8sazZ5OSkjIQ6en5WB/boampLzU1ta6uDmlv7wqjhcdBoDgJBCBnwOcPLnk3FpdDi0sbHu/Gsm/DuxL0rQSCG1u3BoZ4PB7y5fz8fHd3N+pPh8M1Ojp188ZAerE4KbciN09gMAzOzc1RHj0URzEod3T0ZGTwszKLcnPLcjkCtJyc0pzskpycEnRgJ1LaxYvpL33vyJGXvn/kyA8ejhdf/O57753BCItxMHba6ER/XattRW67nwUfGRpNl0LRghae6XS9sBZqYhHtvj0RsFChaJZI1AJBNTTFgYiamia1em+H6FaJ3++/rws6Xq936SGWlyPtwuLyvMfv9njdnuW55aXFFc+Sf9G7ilhABIKr8HdnZ9tsNqMkXVxcRFXq9frGx8fa9A3vCwSNc6Z021tHs4+PGsZRj1IePRRHUW+trvqVKm2dulmna9NoWyCWVhcJXX0b1mh1bWpNs1rbrKtvb2jsbNR31Td0oI+2sbEL+6i1LTi2qaULH/nW1masEMSswuNZrKnBoNxZW9sOt6Lm7ckXExEDNBbRxlJgdIfY1sgOak1XnbK9qarrwVAr22ujpsbivrsqVRteBQFxUT6icIxdHaTBjNtkGrNYbFNT09HZISpsdGCdZXJqenxyuq3pxmCrc6TLZeqOBjqRcA63OyaHbdvbuIs3UXNjKJ+dnUXdCVOHjcaCvMKftpa07aYUffTsCc0P+7sN2EqOPn5HMdjBUZmscnTC5fHfGZqyzy6F7fNr9rlVtJYZn9m1bDA73IvBSZfHs3J7zD7faRy2zfpnlkKO+TUsznu3/IGPVoMfeXy3S0rL3G5X9HMKYCKRk5MjkSgqKupRQVZW6oqKKktKqpD/MLJjTEd7/ToPSTovr6ymplksrsNYj/qysFCCCrW4WFZeWiPTtSYOKBIHai4O1KBFiHT6upo2pbL1oKiqahgbG7tfjGIGfuvWYG/viFrd0tU1NDhovnVrorvb2Ndnamm50d1tMI5NqIuGFEd2ld/fH+oju4W/vNlv7Ozo6MzNzYWaarW6pqamp6env68v4eTZr+ae+u7ID19u/eqLWT8y9Bspj4LH7ygyBKbkp06dcs2sGqdcfIVUUq+WNzeKdbViXZ1YW1ukqODKRS03BzsGhltvDqo7O+u7e+VNjerODpG2VtHa3Dcytbi8M7sYXljezsvn8viC0NbdJV/YNeNNTLyoUjWiooV8qal5p05dPH/+yunT7588eQHlZnJyFgrKCxeunDqViAkZTE1Kuo5+fPzV1NTct946k53M5XY1xu1eitu9GLf7frS9eKVH0SDrgIvQGi3SZ7SNZNDYyooKjcFgvHP7NuY/mAZtboZ7evpQUl+8eO306UuYil24kPL22+cTE9OxGB+fKldreWfa0+J2EemfjdS43aKf2lM4l3j8Mi63AOWmVqvFjdfV1YXJk0qhqFKqhDq1qE6ubGwwGgw0ZwKP31HUaiiwOJycoWHbou+OY3bdPrs2sxh2LWzMejbROueD1hk/WsdcYHDCbnZ6Y5vmlrfml7c8K3dmPWE4uui9Pb+8nZvHhfHh8CbOjEHfaDSUllYoFK2YgSFBIptiJo4pOWbxcrkegUX0kTKRYjE9r65uwpqqqkZ0Kivra6VNnGZ13G5y3G5S3O7laJuU0q1UCHRIutgNh5SXK0tLq0tK5MjKOBaOVlfrr15NGTKMrAe3l32BtcCOvqlbIFDk54swF0TZnZ7OvX69KCurhMMpKyyskCoUOcdbM+J2Mx+KbNwZf39Lri3HTwnpc3p6GhbGvrR3Op0Y9D3zC57ZBc+cx7OwiHm9xWIhRx+/owCj4cqKr+eGwWiyG002tIYRm3HEZhixRhdtw7E10U0jow60pjHXrSFz/8BEa8fAoNEyPOrADjdujg0Pm5DAYvUoqgjksLo6fWVlQ1SdJkj5QNtUVbW3iK3RHZqjm5pj67GmrqI5W1+7z9G03trsSwUpKZyyMuWZM5cSElLRxsdHviZDGsbhKlVrcnKysrY+GP6NxxtcC2z33zTk5wuKiytLS6sQAkGkLS2VlZTIsLJYKEw7Lr/+t96sr++P9GeXZGfNtz8MorrFON7Z2dkX5cZDYKVer5+cnHyMzw6+oByKowB5AsWWy+l88PnnpxGZzy6YTCPt7V1ms3Pa7OzvN7zxxhsvv/zy17727JtvHnc658fHLVNT9t7ePszlY1+AI492d3dxueXQEUnxwUAqlUiQL/UIeIk1SIpIqFgvwsAp1wuFtSJRrUqkz2xURu3EcA9B0V5K7qyWF6uReq9dK8zPF5aVKZBKcRTyNBKqTNaIxYqKymAw8j4wJcc/vCUM07FnuY9mbmbO45xb2h+ziw5/YDkQ+Xoq8ix0cHAQMye0jwSbkFwpjx6WowCa4uf7SMKRRLuSmZmpUNS3tNxqbze8++65t946cfTo0WPHjj333HN5eaUdHYbW1oH8fL5YIgmGdnz+kMPlOX/hQmWlCnMmqVR7P2Akhua8vHIuV/LuuwmoC1GAJiamoUI9d+4yZlEQDjUrNuWlFefq1V+6l/qle1e/dC8F7TP3ria3ymtF+pjQaBHI0zhnrC+V6iAr5uzb23vz+hi4iujDoUeDTRuhT9rPRuSr09VVnA2jPMaHe/fuffzxxx9++OHdu3d/97uPf//7j6IrPv7tb3+LNagB/H7/3ks+rRyio58Dxi+Hw5GQEC+TqaXSeoynr7zyr8eO/er06dMnT5585pm/glIoOuFiYWFJRkbmevC2byW4urbBL+JDXziErHk/oCmG6czMomvXuCkpuQgM1kiK6ekFubnlHI4Am9LS8rG+iC+TyHSFCtX94CpUwgq1RPzp2R4KLW4Ao3EYZcbeu/9cYik/EnsrIs+ZEP7Vdb9/fSUa64HwtMWOW3R5eRlC9/f3O50O/ExGxzyDgx6r1bO0hEFoET8ieIxbfe9ETytPxlGAgqy3tzcvTyCR6DBAX76c9fzzz3/jG3/35S//9Suv/AR2isUakUhTUFA8O+MOhTaQfJCW/P4VobBaJFKLxZ8G0iRkKi9XwdRYOsTIDo9xEgT6SISxkgC7iUXqynLNp1EWWRNzEaeC7ujjDLEMHT2/hs+vNJnGog+ZIvP6/bF3QXsiRh57rgQwtULl6ok++VxY2hcb6xu/UWtbLl9OQo5EXYDJU39/n8cz/1/HZ3766kZNlde3YLVMTTY3N6Fm3Tv7U8wTcxTpAeaVlkp5PAmfLxUKla+99ovvfe/7r7zy4/j4KyKRCutzcwV6fesHH/xmNTreRR31lZVVCYV1MG9fwFRErAO30Ik5h3jQufv73w8Yj0xZXIzT1vJ4FYicnNJYB97jEFSlqalp09O2QHDTt7IejYB/NeRfC6+shn3+TS9iZXP5k0Dft7rpXw2vroXX1kPriEAIlxsIhoJBdFBfRsSuqqrCUI6q1Gw2w0W32z1kGLBPT4rkNac5ZfGpvAqpbGaGfqfkyTm6ubnZ1KRXqXQ3bhhv3jQVFwtRjDY0NCoUitdf/2VDQ3tv71Bf37BIJJ2cnNjYCEUe2a8F+XxedjYfVsGegwKqQbjiYjmG+OvXURuUR57H5qItR0bE1n37I3G+/34G6teiItmJE2dOnox/550Lb7xx8sSJ06gTkF8lEvWlS0nyGk0w/OHiUhDh8W5Y7POT026zxT1tcVusLqvNZbO77A6nA9McZ2SUdttmZ2zzM7a5aLsXLuucZ24Z2uHyl5aWpqenPR4PRnyv1wtNO1pb8oUCXu+Nlh3xUe2/5JaWzDrd0XnaU82TcRS1Fz6S8+fP1dU1KxSR32P6yU/+Dcqi/DKZTCkpV48de6e+vk+pbCstFV25muZfv7PkDducSxcuxJeWVpSVqQQCxUFRXl4LHWFnUlLWsWMn33kn/s033z1+/NSvf30OIsLvffujQkDKzM4uwSEcTllenhBa5+eL0IHTOBumYgUFhUh4SIGrkdnSht3uMBhGLBYnMqBl2o6wWiO/FGuxOKwWp9Xibu1obZ4R3liv7F37bKxK26xy75Lvzu3bjY2NExMTSKX3vyLVyOT/npedvF2m/t9/fnv6K9nSbLd1hvLok3EUP3eUYhwOh8cTR7/sbHnttaNZWZmowNLSUl966Uh6OhdFKjalp2cpVapQeBul3ubmVk9Pd2pqLrwpLVV8fmRllWRmFnO5UiTUwsKKtLQC9NGBlPv2LC2tgfRR75U4cyywiBZrEBxO+ejo+O3bO6g58ebD4fDY2HhDQ09ZWbVQqNBoOtXq9spKrVyOmRwOrO5oMVVpqpM/fu7y7lceii9f8b5YxEUN05acnLywMK/X67lcrkwmQ/rlpGe8+t57f6M//mr3N79e8vyV4pw5Jzn65Mb6UCiEYS4vr4zHqyopqcnOFnzzm//485//4oUXXvjZz45itsTjyXJzxVVVqjt3djBhwiEY9TC5Fovl8A8HHhQY2dEWFAgLCkSI/HwkRSGXK8YadGJb//DA/pmZfEh5f14PR0dHxySSOqTeU6cuvv32uTNnklAknD17+fz5K2gl5Q28Cv7JD/7i7d24dz4bb+3GXd3+h/fjk1WqhoyMDIz1w8PDELStrQ31QWtra6Ouvq6xWaXX1zY03ui/OTY2RmP9E3MUIEN0dfUqldq6uob6+ubKymouly8QiNTqBo2mESuVSs3ExCRs3jvgk0cD09OP/hugw8CCEd3pfFCU6C8kDOfniwsLK9EWFEjz8nAnoCNBh8+vKi/SpRelvvlR3IndR8Sxub9UVavvfnDXaDT29/ej5oGdeCHMnPBCbpdrxumacbjn3LOjuBXGxoL0Hf4TdBQgOUUjFA6Hdna2b0fZ2trEIgKbMPff9xca+Mxg7Z+XzzyNxBtYWFiorq6TyWqrq9VyeZ1cro519lqZtkRanDv5Otf+nwW2Xz0YHMt/yMypW6EdVOSYM/VG2Xv6+RAdHR03b94kR5+wo19QkM4hbjAYOCDWQ8HQpvd/wsuPiK3V/14PrOPGw0mQnlGXo38Qe6/3dEOO/vH8EYXiA1/5E38o5CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTrkKME65CjBOuQowTqfcZQg2GTPUYJgl7i4/wNojt0NUXmIGwAAAABJRU5ErkJggg== + + + + + \ No newline at end of file diff --git a/src/gh/components/DF_xml_exporter/code.py b/src/gh/components/DF_xml_exporter/code.py new file mode 100644 index 00000000..e3ae43b8 --- /dev/null +++ b/src/gh/components/DF_xml_exporter/code.py @@ -0,0 +1,48 @@ +#! python3 +# r: diffCheck==0.0.9 + +import System +import typing + +import Rhino +import Rhino.Geometry as rg + +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]): + """ + This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them 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] + + return o_xml, o_joints, o_sides \ 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 new file mode 100644 index 0000000000000000000000000000000000000000..c9e0b54e8008a1a82afe3a6643e7b31733369308 GIT binary patch literal 5660 zcmeHLc~}$I79W=fiXiv|wG?#>xKN#BX0lI{0)|MUMkz)Vwd!PM5=KcTBm)WfK(wE@ zprX~5y40!#o{B3Kty|Srr3zN9T9>+@;*<6X+RAgO+q($}*yUNj@AduhK9iYb=H7FE z_xyhMoHO^E+3~~T0{lY#AP5T3>tYkYe>czB&IkNfxzzU|sP%(P<7hsCbisB9XJ%6v zn9r~?Fym&;5ad2zTQKCk>VE#Y_m;2DpSWj%qN7h|O#b1uV}a>A`+w>faj|5!u5eJW0@7m*yPWq$a1J0oWAV+s<@1-KBHRg zKYa8?r%2t+?4@VtWnXSv8r>l{pftMoTfIW)}N{@-7zDiB&pO~ zp`5a!z?7D1u&ubL-t7)(ACMQ;qf_rmR|KC)HdJ5jJvg%L3(Jh_bIyhMmDTO8*tn}m zee3h`@psQ}&RQy)ydxtoaZK%nqH9lTc1+11pQ*0dmq^ra4)2+L;O+Uu=F_=_tG*o6 z<1N$Tx4B7OzvZs`o~l`WDDRZ9epzT?U0`R)rq0VMp}C9xI_qIam*KMvVm{quo&PZy6{T9d7-dvm+%)X$In%d|ID zGsJ6`Rn?OT#*Rb3wDh_5u6)9_xMk!2GWC46e^!g{<755-k6K|*J3k6sMz0IFFsGV> zpjIVj27Qcy_R;y1eNAISFK`ol!W z_cMK_7R{59MR7#%-(+?oAac2i&flwa{>^Q{1eB3BDEG zE05$3R_Vh=8t45qV|j(&4dm-dMTf@Rs}}ip-Fn^s4BN5SG;PGf>Fr*VrmSq;0UIMt z7+T0i)m`byKZy@uKef0ZBegvu7ho|hj-VwcBI3%}Pm%Vi0mUg>8J|Vw8 z?aA1cQ%=`zD9b0m}=4l`1jlPM)Fhqg+mLIHg&}Jebc2FY(xKj&~dEQQlL@t+0=n@M#hed=bl}Ztci*OtP z7Kk&$#*=Qu<_z~hG+@LsPRhaBd6u)m9!%22rSWQk0QAGp{Il8(h9-EMvrz@0hsaIZ zMVJs3S*@a$Bb>Z89e^}C^qV7`Mo`>E35=6Vb5M*now4!ZEg|CchWI7~4RX^s@H4NZxd6vhfboxnfrIeU9D$8*kP&fYZaIR~4%y~J9&#IxpRm7g2q z>G_p8@bkB4cqW<`8(0|(L@Y<8dA!xfK8ppKqga|~a)ywiCJHxGCPayf&4^egp%Dc} zV~ELwkxDscRxnCg3qZZi$&)sU@c@D;ge(9fJi-(<}>j2xGu7I-9rJv^Gg44??mBu_TMNeC1iaw8@tq*6kR^+)lRaDWhN z&UlfvC*@%km>$HNj&<^!Bg5O&PzOdZsSS4xw<)Z*0Kl*}l?jq+AWV5_(q2yiT01EdMX$(eZ<>0n|kKwq^W##3qG_-DBa;~)ObmkY#sASS+VL&}^EFk}hF)1Z!6G`C+F2kh=$w(B4Ng|^Wv%*X=m{evq$&}AK z{bI&A+^;b|evdEa2{cq;#3Y17-WX;71F~|Z)GRdtief3FL_n5`K`8;n38Q2*O)@4* zqM-h7$VyQ$E=4H{kTo%gL@rh$BxxoQQi@YjTuRAEvY`{o1f*VO7yENZZK%^Fb4tO&;~XMV9z0H+H^E#0`T?E{4`dNKXVEgel^KU z>HA8qS8~0S0xxC!D!N|D^->DFl<}+R`mf35*ZkUov4Op<3%rz29+%GrFEo5iL*in+ zuQs3unq5=DReQTG$q7NiaL?JwT@;lL8hv@aLF-%7*0+Pa=kTv@bpcI%^|3KVU3u-% zm{t(luI)NOMmi#?O*wZmdJ4xBjs E-^)b$v;Y7A literal 0 HcmV?d00001 diff --git a/src/gh/components/DF_xml_exporter/metadata.json b/src/gh/components/DF_xml_exporter/metadata.json new file mode 100644 index 00000000..a9d8cda0 --- /dev/null +++ b/src/gh/components/DF_xml_exporter/metadata.json @@ -0,0 +1,92 @@ +{ + "name": "DFXMLExporter", + "nickname": "XMLout", + "category": "diffCheck", + "subcategory": "Utility", + "description": "This component reads breps, convert them to DFBeams and DFAssemblies and export it to XML.", + "exposure": 4, + "instanceGuid": "cdae4bd5-d18e-4b06-9367-791b6b1f6837", + "ghpython": { + "hideOutput": true, + "hideInput": true, + "isAdvancedMode": true, + "marshalOutGuids": true, + "iconDisplay": 2, + "inputParameters": [ + { + "name": "i_dump", + "nickname": "i_dump", + "description": "Press button to export xml", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "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.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "item", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "str" + }, + { + "name": "i_breps", + "nickname": "i_breps", + "description": "The breps of the structure.", + "optional": true, + "allowTreeAccess": true, + "showTypeHints": true, + "scriptParamAccess": "list", + "wireDisplay": "default", + "sourceCount": 0, + "typeHintID": "brep" + } + ], + "outputParameters": [ + { + "name": "o_xml", + "nickname": "o_xml", + "description": "The string of xml to be exported.", + "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 + } + ] + } +} \ No newline at end of file diff --git a/src/gh/diffCheck/README.md b/src/gh/diffCheck/README.md new file mode 100644 index 00000000..afa64734 --- /dev/null +++ b/src/gh/diffCheck/README.md @@ -0,0 +1,5 @@ +# DiffCheck Grasshopper Plugin + +DiffCheck is a plugin for Rhino/Grasshopper that allows the user to compare a 3D model with its scan. + +More information to come \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/__init__.py b/src/gh/diffCheck/diffCheck/__init__.py new file mode 100644 index 00000000..2418e6b6 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/__init__.py @@ -0,0 +1 @@ +__version__ = "0.0.9" \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_geometries.py b/src/gh/diffCheck/diffCheck/df_geometries.py new file mode 100644 index 00000000..47dbff55 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_geometries.py @@ -0,0 +1,311 @@ +import os +from datetime import datetime +from dataclasses import dataclass +import typing +import uuid + +import Rhino +import Rhino.Geometry as rg + +import xml.etree.ElementTree as ET +from xml.dom.minidom import parseString + +import diffCheck.df_joint_detector + + +@dataclass +class DFVertex: + """ + This class represents a vertex, a simple container with 3 coordinates + """ + + x: float + y: float + z: float + + def __post_init__(self): + self.x = self.x or 0.0 + self.y = self.y or 0.0 + self.z = self.z or 0.0 + + def __repr__(self): + return f"Vertex: X={self.x}, Y={self.y}, Z={self.z}" + + def __hash__(self): + return hash((self.x, self.y, self.z)) + + def __eq__(self, other): + if isinstance(other, DFVertex): + return self.x == other.x and self.y == other.y and self.z == other.z + return False + + @classmethod + def from_rg_point3d(cls, point: rg.Point3d): + """ + Create a DFVertex from a Rhino Point3d object + + :param point: The Rhino Point3d object + :return vertex: The DFVertex object + """ + return cls(point.X, point.Y, point.Z) + + def to_rg_point3d(self): + """ + Convert the vertex to a Rhino Point3d object + + :return point: The Rhino Point3d object + """ + return rg.Point3d(self.x, self.y, self.z) + + +@dataclass +class DFFace: + """ + This class represents a face, in diffCheck, a face is a collection of vertices. + """ + + # just as breps a first outer loop and then inner loops of DFVertices + all_loops: typing.List[typing.List[DFVertex]] + joint_id: int = None + + def __post_init__(self): + if len(self.all_loops[0]) < 3: + raise ValueError("A face must have at least 3 vertices") + self.all_loops = self.all_loops + + self.joint_id = self.joint_id + self.__is_joint = False + self.__id = uuid.uuid4().int + + def __repr__(self): + return f"Face id: {len(self.id)}, IsJoint: {self.is_joint} Loops: {len(self.all_loops)}" + + def __hash__(self): + outer_loop = tuple( + tuple(vertex.__dict__.values()) for vertex in self.all_loops[0] + ) + inner_loops = tuple( + tuple(vertex.__dict__.values()) + for loop in self.all_loops[1:] + for vertex in loop + ) + return hash((outer_loop, inner_loops)) + + def __eq__(self, other): + if isinstance(other, DFFace): + return self.all_loops == other.all_loops + return False + + @classmethod + def from_brep(cls, brep_face: rg.BrepFace, joint_id: int = None): + """ + Create a DFFace from a Rhino Brep face + + :param brep_face: The Rhino Brep face + :param joint_id: The joint id + :return face: The DFFace object + """ + all_loops = [] + + for idx, loop in enumerate(brep_face.Loops): + loop_trims = loop.Trims + loop_curve = loop.To3dCurve() + loop_curve = loop_curve.ToNurbsCurve() + loop_vertices = loop_curve.Points + loop = [] + for l_v in loop_vertices: + vertex = DFVertex(l_v.X, l_v.Y, l_v.Z) + loop.append(vertex) + all_loops.append(loop) + + df_face = cls(all_loops, joint_id) + df_face._brepface = brep_face + + return df_face + + def to_brep(self): + """ + Convert the face to a Rhino Brep planar face + + :return brep_face: The Rhino Brep planar face + """ + brep_curves = [] + + for loop in self.all_loops: + inner_vertices = [ + rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in loop + ] + inner_polyline = rg.Polyline(inner_vertices) + inner_curve = inner_polyline.ToNurbsCurve() + brep_curves.append(inner_curve) + + brep = rg.Brep.CreatePlanarBreps( + brep_curves, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance + )[0] + + return brep + + def to_mesh(self): + """ + Convert the face to a Rhino Mesh + + :return mesh: The Rhino Mesh object + """ + mesh = rg.Mesh.CreateFromBrep(self.to_brep())[0] + return mesh + + @property + def is_joint(self): + if self.joint_id is not None: + self.__is_joint = True + return True + self.__is_joint = False + return False + + @property + def id(self): + return self.__id + + +@dataclass +class DFBeam: + """ + This class represents a beam, in diffCheck, a beam is a collection of faces + """ + + name: str + faces: typing.List[DFFace] + + def __post_init__(self): + self.name = self.name or "Unnamed Beam" + self.faces = self.faces or [] + self._joint_faces = [] + self._side_faces = [] + + self.__id = uuid.uuid4().int + + @classmethod + def from_brep(cls, brep): + """ + Create a DFBeam from a RhinoBrep object. + It also removes duplicates and creates a list of unique faces. + """ + 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]) + faces.append(face) + beam = cls("Beam", faces) + return beam + + def __repr__(self): + return f"Beam: {self.name}, Faces: {len(self.faces)}" + + @property + def id(self): + return self.__id + + @property + def joint_faces(self): + return [face for face in self.faces if face.is_joint] + + @property + def side_faces(self): + return [face for face in self.faces if not face.is_joint] + + +@dataclass +class DFAssembly: + """ + This class represents an assembly of beams + """ + + beams: typing.List[DFBeam] + name: str + + def __post_init__(self): + self.beams = self.beams + self.name = self.name or "Unnamed Assembly" + + self._all_jointfaces = [] + self._all_sidefaces = [] + + def __repr__(self): + return f"Assembly: {self.name}, Beams: {len(self.beams)}" + + def add_beam(self, beam: DFBeam): + self.beams.append(beam) + + def remove_beam(self, beam_id: int): + self.beams = [beam for beam in self.beams if beam.id != beam_id] + + def to_xml(self): + """ + Dump the assembly's meshes to an XML file. On top of the DiffCheck datatypes and structure, + we export the underlaying beams's meshes from Rhino as vertices and faces. + + :return xml_string: The pretty XML string + """ + root = ET.Element("DFAssembly") + root.set("name", self.name) + # dfbeams + for beam in self.beams: + beam_elem = ET.SubElement(root, "DFBeam") + beam_elem.set("name", beam.name) + beam_elem.set("id", str(beam.id)) + # dffaces + for face in beam.faces: + face_elem = ET.SubElement(beam_elem, "DFFace") + face_elem.set("id", str(face.id)) + face_elem.set("is_joint", str(face.is_joint)) + face_elem.set("joint_id", str(face.joint_id)) + # export linked mesh + facerhmesh_elem = ET.SubElement(face_elem, "RhMesh") + mesh = face.to_mesh() + mesh_vertices = mesh.Vertices + for idx, vertex in enumerate(mesh_vertices): + facerhmesh_vertex_elem = ET.SubElement( + facerhmesh_elem, "RhMeshVertex" + ) + facerhmesh_vertex_elem.set("x", str(vertex.X)) + facerhmesh_vertex_elem.set("y", str(vertex.Y)) + facerhmesh_vertex_elem.set("z", str(vertex.Z)) + mesh_faces = mesh.Faces + for idx, face in enumerate(mesh_faces): + facerhmesh_face_elem = ET.SubElement(facerhmesh_elem, "RhMeshFace") + facerhmesh_face_elem.set("v1", str(face.A)) + facerhmesh_face_elem.set("v2", str(face.B)) + facerhmesh_face_elem.set("v3", str(face.C)) + facerhmesh_face_elem.set("v4", str(face.D)) + + tree = ET.ElementTree(root) + xml_string = ET.tostring(root, encoding="unicode") + dom = parseString(xml_string) + pretty_xml = dom.toprettyxml() + + return pretty_xml + + def dump_xml(self, pretty_xml: str, dir: str): + """ + Dump the pretty XML to a file + + :param pretty_xml: The pretty XML string + :param dir: The directory to save the XML + """ + timestamp = datetime.now().strftime("%Y%m%d%H%M%S") + file_path = os.path.join(dir, f"{self.name}_{timestamp}.xml") + + with open(file_path, "w") as f: + f.write(pretty_xml) + + @property + def all_joint_faces(self): + for beam in self.beams: + self._all_jointfaces.extend(beam.joint_faces) + return self._all_jointfaces + + @property + def all_side_faces(self): + for beam in self.beams: + self._all_sidefaces.extend(beam.side_faces) + return self._all_sidefaces diff --git a/src/gh/diffCheck/diffCheck/df_joint_detector.py b/src/gh/diffCheck/diffCheck/df_joint_detector.py new file mode 100644 index 00000000..2a9f0e93 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_joint_detector.py @@ -0,0 +1,206 @@ +import Rhino +import scriptcontext as sc +import Rhino.Geometry as rg + +import typing +from dataclasses import dataclass + +import diffCheck.df_util +import diffCheck.df_transformations + +from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML + + +@dataclass +class JointDetector: + """ + This class is responsible for detecting joints in a 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 = [] + + def _compute_mass_center(self, b_face: rg.BrepFace) -> rg.Point3d: + """ + Compute the mass center of a brep face + + :param b_face: The brep face to compute the mass center from + :return mass_center: The mass center of the brep face + """ + amp = rg.AreaMassProperties.Compute(b_face) + if amp: + return amp.Centroid + return None + + def run(self) : + """ + Run the joint detector + + :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) + + # 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) + 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 \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck/df_transformations.py b/src/gh/diffCheck/diffCheck/df_transformations.py new file mode 100644 index 00000000..20d529b8 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_transformations.py @@ -0,0 +1,135 @@ +import Rhino +import Rhino.Geometry as rg +import scriptcontext as sc + +import numpy as np +import math + + +def get_inverse_transformation( + x_form: Rhino.Geometry.Transform, +) -> Rhino.Geometry.Transform: + """ + Get the inverse of a transformation + + :param x_form: the transformation to get the inverse from + :return: the inverse transformation + """ + transformation_matrix = np.array( + [ + [x_form.M00, x_form.M01, x_form.M02, x_form.M03], + [x_form.M10, x_form.M11, x_form.M12, x_form.M13], + [x_form.M20, x_form.M21, x_form.M22, x_form.M23], + [x_form.M30, x_form.M31, x_form.M32, x_form.M33], + ] + ) + inverse_transformation_matrix = np.linalg.inv(transformation_matrix) + + x_form_back = Rhino.Geometry.Transform() + for i in range(4): + for j in range(4): + x_form_back[i, j] = inverse_transformation_matrix[i, j] + + return x_form_back + + +def pln_2_pln_world_transform(brep: Rhino.Geometry.Brep) -> Rhino.Geometry.Transform: + """ + Transform a brep (beam) to the world plane + + :param brep: the brep to transform + :return: the transformation + """ + + def _get_lowest_brep_vertex(brep) -> Rhino.Geometry.Point3d: + """ + Get the the vertex with the lowest y,x and z values + + :param brep: the brep to get the lowest vertex from + :return: the lowest vertex + """ + biggest_vertices = brep.Vertices + lowest_x = 0 + lowest_y = 0 + lowest_z = 0 + for vertex in biggest_vertices: + if vertex.Location.X < lowest_x: + lowest_x = vertex.Location.X + if vertex.Location.Y < lowest_y: + lowest_y = vertex.Location.Y + if vertex.Location.Z < lowest_z: + lowest_z = vertex.Location.Z + return Rhino.Geometry.Point3d(lowest_x, lowest_y, lowest_z) + + # find the longest edge of the brep + edges = brep.Edges + longest_edge = None + longest_edge_length = 0 + for edge in edges: + if edge.GetLength() > longest_edge_length: + longest_edge_length = edge.GetLength() + longest_edge = edge + + # find biggest face + face_indices = longest_edge.AdjacentFaces() + faces = [brep.Faces[face_index] for face_index in face_indices] + biggest_face = None + biggest_face_area = 0 + for face in faces: + if rg.AreaMassProperties.Compute(face).Area > biggest_face_area: + biggest_face_area = rg.AreaMassProperties.Compute(face).Area + biggest_face = face + + # 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 + plane_src = biggest_face.TryGetPlane()[1] + plane_tgt = Rhino.Geometry.Plane.WorldXY + + # plane to plane transformation + x_form_pln2pln = Rhino.Geometry.Transform.PlaneToPlane(plane_src, plane_tgt) + brep.Transform(x_form_pln2pln) + + # adjust to x,y,z positive + lowest_vertex = _get_lowest_brep_vertex(brep) + x_form_transl_A = Rhino.Geometry.Transform.Translation(rg.Vector3d(-lowest_vertex)) + brep.Transform(x_form_transl_A) + + # aabb + bbox = brep.GetBoundingBox(True) + bbox_corners = bbox.GetCorners() + y_val_sum = 0 + x_val_sum = 0 + for corner in bbox_corners: + y_val_sum += corner.Y + x_val_sum += corner.X + + # check if a 90 deg rotation is needed (for the joint detector) + x_form_transl_B = None + x_form_rot90z = None + if x_val_sum > y_val_sum: + # AABB is alligned to x axis. No rotation needed + pass + else: + # AABB is not alligned to y axis. A 90 deg rotation is needed. + x_form_rot90z = Rhino.Geometry.Transform.Rotation( + math.radians(90), rg.Vector3d.ZAxis, rg.Point3d.Origin + ) + brep.Transform(x_form_rot90z) + lowest_vertex = _get_lowest_brep_vertex(brep) + + x_form_transl_B = Rhino.Geometry.Transform.Translation( + rg.Vector3d(-lowest_vertex) + ) + brep.Transform(x_form_transl_B) + + # resume the transformations in one + x_form = Rhino.Geometry.Transform.Identity + if x_form_transl_B: + Rhino.Geometry.Transform.TryGetInverse(x_form_transl_B) + Rhino.Geometry.Transform.TryGetInverse(x_form_rot90z) + x_form = x_form_transl_B * x_form_rot90z + x_form = x_form * x_form_transl_A * x_form_pln2pln + + return x_form diff --git a/src/gh/diffCheck/diffCheck/df_util.py b/src/gh/diffCheck/diffCheck/df_util.py new file mode 100644 index 00000000..0ccf3a0a --- /dev/null +++ b/src/gh/diffCheck/diffCheck/df_util.py @@ -0,0 +1,139 @@ +import Rhino +import Rhino.Geometry as rg +import rhinoscriptsyntax as rs +import scriptcontext as sc + +import typing + + +def explode_brep(brep) -> typing.List[Rhino.Geometry.Brep]: + """ Explode a brep into its faces """ + exploded_objects = [] + if brep.IsSolid: + for face in brep.Faces: + face_brep = face.DuplicateFace(False) + if face_brep: + exploded_objects.append(face_brep) + else: + for face in brep.Faces: + face_brep = face.DuplicateFace(False) + if face_brep: + exploded_objects.append(face_brep) + return exploded_objects + + +def get_crv_circle_center(crv) -> rg.Point3d: + """ Get the center of a circle """ + bbox = crv.GetBoundingBox(True) + bbox_b = bbox.ToBrep() + center_point = bbox_b.GetBoundingBox(True).Center + return center_point + + +def is_pt_unique_in_dict(pt, pt_dict) -> bool: + """ + Detect if the point exists in the dictionary, and if so, return the index + + :param pt: the point to check + :param pt_dict: the dictionary to check + :return: True if the point is unique, False otherwise + """ + is_unique = True + for pt_dict in pt_dict.keys(): + X_a = round(pt.X, 3) + Y_a = round(pt.Y, 3) + Z_a = round(pt.Z, 3) + + X_b = round(pt_dict.X, 3) + Y_b = round(pt_dict.Y, 3) + Z_b = round(pt_dict.Z, 3) + + if X_a == X_b and Y_a == Y_b and Z_a == Z_b: + is_unique = False + break + return is_unique + + +def is_pt_unique_in_list(pt, list) -> bool: + """ + Detect if the point exists in the list, and if so, return the index + + :param pt: the point to check + :param list: the list to check + :return: True if the point is unique, False otherwise + """ + is_unique = True + for pt_list in list: + X_a = round(pt.X, 3) + Y_a = round(pt.Y, 3) + Z_a = round(pt.Z, 3) + + X_b = round(pt_list.X, 3) + Y_b = round(pt_list.Y, 3) + Z_b = round(pt_list.Z, 3) + + if X_a == X_b and Y_a == Y_b and Z_a == Z_b: + is_unique = False + break + return is_unique + + +def detect_idx_pt_in_list(pt, list) -> int: + """ + Detect the index of a point in a list + + :param pt: the point to check + :param list: the list to check + :return: the index of the point in the list + """ + idx = -1 + for pt_list in list: + idx += 1 + X_a = round(pt.X, 3) + Y_a = round(pt.Y, 3) + Z_a = round(pt.Z, 3) + + X_b = round(pt_list.X, 3) + Y_b = round(pt_list.Y, 3) + Z_b = round(pt_list.Z, 3) + + if X_a == X_b and Y_a == Y_b and Z_a == Z_b: + return idx + return idx + + +def compute_ordered_vertices(brep_face) -> typing.List[Rhino.Geometry.Point3d]: + """ Retrieve the ordered vertices of a brep face """ + sorted_vertices = [] + + edges = brep_face.DuplicateEdgeCurves() + edges = list(set(edges)) + + edges_sorted = [] + while len(edges) > 0: + if len(edges_sorted) == 0: + edges_sorted.append(edges[0]) + edges.pop(0) + else: + for edge in edges: + if edges_sorted[-1].PointAtStart == edge.PointAtStart: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + elif edges_sorted[-1].PointAtStart == edge.PointAtEnd: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + elif edges_sorted[-1].PointAtEnd == edge.PointAtStart: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + elif edges_sorted[-1].PointAtEnd == edge.PointAtEnd: + edges_sorted.append(edge) + edges.pop(edges.index(edge)) + break + + for edge in edges_sorted: + sorted_vertices.append(edge.PointAtStart) + + return sorted_vertices diff --git a/src/gh/diffCheck/diffCheck/newmodule.py b/src/gh/diffCheck/diffCheck/newmodule.py new file mode 100644 index 00000000..452195e1 --- /dev/null +++ b/src/gh/diffCheck/diffCheck/newmodule.py @@ -0,0 +1,5 @@ + + + +def test_new_mdoule(): + print("hello from test_new_mdoule") \ No newline at end of file diff --git a/src/gh/diffCheck/diffCheck_app.py b/src/gh/diffCheck/diffCheck_app.py new file mode 100644 index 00000000..a0f84437 --- /dev/null +++ b/src/gh/diffCheck/diffCheck_app.py @@ -0,0 +1,40 @@ +#! python3 + +import Rhino +import Rhino.Geometry as rg + +import os +import typing + +import diffCheck +import diffCheck.df_geometries + +print(diffCheck.__version__) + + +if __name__ == "__main__": + """ + Main function to test the package + :param i_breps: list of breps + :param i_export_dir: directory to export the xml + :param i_dump: whether to dump the xml + """ + # o_joints = diffCheck.df_joint_detector.JointDetector(i_breps[0]).run() + # beams + beams = [] + for brep in i_breps: + beam = diffCheck.df_geometries.DFBeam.from_brep(brep) + beams.append(beam) + + # assembly + assembly1 = diffCheck.df_geometries.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] diff --git a/src/gh/diffCheck/setup.py b/src/gh/diffCheck/setup.py new file mode 100644 index 00000000..921b98c4 --- /dev/null +++ b/src/gh/diffCheck/setup.py @@ -0,0 +1,22 @@ +from setuptools import setup, find_packages + +setup( + name="diffCheck", + version="0.0.9", + packages=find_packages(), + install_requires=[ + "numpy", + # other dependencies... + ], + description="DiffCheck is a package to check the differences between two timber structures", + long_description=open("README.md").read(), + long_description_content_type="text/markdown", + author="Andrea Settimi, Damien Gilliard, Eleni Skevaki, Marirena Kladeftira, Julien Gamerro, Stefana Parascho, and Yves Weinand", + author_email="andrea.settimi@epfl.ch", + url="https://github.com/diffCheckOrg/diffCheck", + classifiers=[ + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + ], +) diff --git a/src/gh/tester.ghx b/src/gh/tester.ghx new file mode 100644 index 00000000..904d106d --- /dev/null +++ b/src/gh/tester.ghx @@ -0,0 +1,5328 @@ + + + + + + + + 0 + 2 + 2 + + + + + + + 1 + 0 + 8 + + + + + + 103ba181-3a3b-4b4e-b795-e493222bd4e6 + Shaded + 1 + + 100;102;0;255 + + + 100;0;150;0 + + + + + + 638480369678877464 + + false + tester.ghx + + + + + 0 + + + + + + 320 + 6 + + 0.25101504 + + + + + 0 + + + + + + + 0 + + + + + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py + not_found + F:\diffCheck\src\gh\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck\diffCheck_app.py + F:\diffCheck\src\gh\diffCheck\diffCheck\test.py + + + + + 2 + + + + + Robert McNeel & Associates + 00000000-0000-0000-0000-000000000000 + Grasshopper + 8.6.24101.5001 + + + + + RhinoCodePluginGH, Version=8.6.24101.5001, Culture=neutral, PublicKeyToken=552281e97c755530 + 8.6.24101.5001 + + 066d0a87-236f-4eae-a0f4-9e42f5327962 + RhinoCodePluginGH + + + + + + + + 52 + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABhmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTtIw1AUhv+mSkUqDhZ84JChCoIFURFHiWIRLJS2QqsOJjd9QZOGJMXFUXAtOPhYrDq4OOvq4CoIgg8QZwcnRRcp8dyk0CJU8MDlfvz3/j/nngsItRLTrI4JQNNtMxGVxHRmVQy8wodB9EPAmMwsI5ZcTKFtfd3Tbaq7CM/C/6pHzVoM8InEc8wwbeIN4plN2+C8TxxiBVklPiceN6lB4keuKx6/cc67LPDMkJlKzBOHiMV8CystzAqmRjxNHFY1nfKFtMcq5y3OWqnCGn3yFwaz+kqS67SGEcUSYohDhIIKiijBRoR2nRQLCTqX2viHXH+cXAq5imDkWEAZGmTXD/4Hv2dr5aYmvaSgBHS+OM7HCBDYBepVx/k+dpz6CeB/Bq70pr9cA2Y/Sa82tfAR0LsNXFw3NWUPuNwBBp4M2ZRdyU9LyOWA9zP6pgzQdwt0r3lza5zj9AFI0ayWb4CDQ2A0T9nrbd7d1Tq3P++484P0A3o2cqrMnZbPAAAACXBIWXMAAAsMAAALDAE/QCLIAAAAB3RJTUUH6AEZFwkM569AfQAABNpJREFUSEu9kntMU3cYhguoOOZ1ujmFXqQtBcEpIwoTxOGQolLwUp24OFS0sEqh0oIV0CIg1FLKsbTlNooFKhRF8TajziW6zYFxcckW9bhlm9uiLk6nAyuWy7tTc0iI4w9l2Z7k++/7nveX9xzGfw+LWMhgV4hd48Y2iN1ZBvEoFiH2ZOrFXkydeJzPvsn05ghhmxIZnCq4xo1TCXe2GaPZJniyKvAqi8AEps5Eb/4LOJVfDQZ4PAswYizLgHHMckxi6vqmeJfMpjdHCNscQgUMDAaMoQJeoQLGUwGTfXR43bvkM3pz5LhxzHXuVMAoqp4x7Ap4sfZT9ejxmk8ppnlrEDE142bCxA3k2vHryKSZYnJrcPxS+vTFcGMR09w55keuAFf/Xs/612OKjxZvepdAMF2NFROT8IHv+5CEroZskeiaJC7Cgz5/MTzYRsVg/64PPJFZhqlUwHTvYrBmFGBZsAybw9ZCGr0SyhXLoVobk0Gfvhju/CJPD2GnY7SwE57CDngJL2FCzBeYsuQC/OM/Rdiq45AsWQP5ygSoEpdi94fRDyslc6SWNH9pvVwgtWb7SQ/k8CfRumHY2ithpACD45YyAA9JP3ykPQiQdSNh4zlsS1gFZaIIuZuEKEx5DwZZKKyZAWhUCdC0i5o9fIK2Pcfm7gmMlIF7zwd4b3MiMMOBhdvvQLJ6C+TrV0CVvBz5qTEoTo+CThmBAzlBaNotgK3AD80av97mUt4s2joESX/ZULlr3pD2I1Deg/nKLiQmN0O2Xoys5HjsksaiUB6Nfcp3UZ67ANX5IThYRMn38dFSxoed4J+lrTRbngio1zuHyid9NABeei+CFQ5EZ91FcsZZyBTtUGUfRGFuLXRqAuaCEtQX51GvlqCllBLr+Wg18HDIzIO9xnc5baeQ9J0YKncNU9aPOYoeLNzZhXWZV5CiOI3MHW3Iy21AsboSRIEe1ZpCNGh3okUXjhaCkhspeRUPh2u5aLNwb1isM0a7Xi98Xj49rR8CuRPvqBxYtuNXbFKcR5rqBLLz7MjPt0BbZIRRo0WdLh82fRLs+/k4ZKLk1ZT4Yy6O1FPT6IujzTMzqT/HGUv1nzp0eOnO1JAsR+rinPuZiYrOPonqLOS57chRH8TevbUo01D16IrRSOSgwxCJK6ZgXK2ZjW/rZuGa1Q+kjYfvW7i40ep7ne5oeNbIL6mTsi9gW95pKNVtUBc1QKOpwn5dGarLC3GxYiN+Mkfgds183LcEo8sahB6bP3rtfAwc5qK3nbORVv0TUdpF1jplx+OtueeRvvskVIV2FJTUQ1tqgpHQotm4EzeMi3GrKhx36+bhgXUuum2B6LEL0NfGQ/8x38u0anhWbe/Yu0H1OZm66wyZuecomVfSRBZpa0h9OUGaK4rJL43rcbN6EX6xhOF3awge2mbjcWsAnrb5oe84F49PcUJp1ctz2SCM+64qGj/URuK3A6G4Z5uLR/YgONoEcB7jwXlqZiO9+vKcIaLHfG2KJa/VLMaPlnDcts3DHy1z8NfhQDxp96Pk3O77Z9gz6PWXp7MiTnG1MhbX66Lwc8MC3GkOwYNDb6GrPQA9J/lwnPbNo1dHRqdJFPVNbYyItEaKbjWFie62vi3680iQqPu4v+jpJzzRg3PssfTq/wGD8Tedsdp6457pjwAAAABJRU5ErkJggg== + + dcf18e47-99f2-42d5-9ca4-7e6aee82d9b6 + true + true + false + true + script-sync cpython + scsy-cpy + 1 + + false + false + false + + + + + + 177 + 92 + 171 + 104 + + + 284 + 144 + + + + + + 5 + 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 + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 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. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + 083c2fe3-a45a-43c1-8f85-ce20a4a69a99 + true + btn + btn + true + 0 + true + 5f8bfbf4-70d5-46ba-90fa-f3804e9a9032 + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 179 + 94 + 90 + 20 + + + 225.5 + 104 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + e0ef2066-70a4-441f-906b-8a4afddb0692 + true + i_export_dir + i_export_dir + true + 0 + true + 77c76654-6be3-4843-b564-afe44705740d + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 179 + 114 + 90 + 20 + + + 225.5 + 124 + + + + + + + + 1 + true + Converts to collection of Breps (Boundary REPresentations) + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + ae8c9c0d-8d6a-4a8c-812a-110846a2031c + true + i_breps + i_breps + true + 1 + true + 0f309845-29e6-43ae-b255-cdb5c2d13da9 + 1 + + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 179 + 134 + 90 + 20 + + + 225.5 + 144 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + d9632669-508e-4a03-b9bc-a5d740ef546f + true + i_assembly_name + i_assembly_name + true + 0 + true + 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 179 + 154 + 90 + 20 + + + 225.5 + 164 + + + + + + + + true + Converts to collection of boolean values + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 1e3c2c63-ede9-4faf-9790-a3d1b9350ba3 + true + i_dump + i_dump + true + 0 + true + 254a4a2f-d415-488e-9851-4a763f1ba58f + 1 + + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 179 + 174 + 90 + 20 + + + 225.5 + 184 + + + + + + + + false + The redirected standard output of the component scriptsync. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 55cc2102-ec2b-4f6f-ba16-74e8aed9df42 + true + stdout + stdout + false + 0 + true + 0 + The redirected standard output of the component scriptsync. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 299 + 94 + 47 + 25 + + + 322.5 + 106.5 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + a849584f-8d8a-4547-a1a4-36be0bf3ac37 + true + o_xml + o_xml + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 299 + 119 + 47 + 25 + + + 322.5 + 131.5 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 178951a0-3c74-4810-aef0-87cc45b0502c + true + o_joints + o_joints + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 299 + 144 + 47 + 25 + + + 322.5 + 156.5 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 76758d37-2a1d-412d-b85b-149ecda8a020 + true + o_sides + o_sides + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 299 + 169 + 47 + 25 + + + 322.5 + 181.5 + + + + + + + + + + false + #! python3
# r: numpy

from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            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.
        """
        try:
            with open(path, 'r') as f:
                # add the path and sub directories to the sys path
                path_dir = os.path.dirname(path)
                sub_dirs = [d for d in os.listdir(path_dir) if os.path.isdir(os.path.join(path_dir, d))]
                for sub_dir in sub_dirs:
                    print(sub_dir)
                    sys.path.append(os.path.join(path_dir, sub_dir))
                sys.path.append(path_dir)

                # 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)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            i_export_dir,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name,
            i_dump: bool):
        """ 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(btn)

        # 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())

        path_dir = os.path.dirname(self.path)
        sub_dirs = []
        for root, dirs, files in os.walk(path_dir):
            for d in dirs:
                sub_dirs.append(os.path.join(root, d))
                print(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)

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

    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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 5f8bfbf4-70d5-46ba-90fa-f3804e9a9032 + true + Button + + false + 0 + + + + + + 80 + 79 + 66 + 22 + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + 0f309845-29e6-43ae-b255-cdb5c2d13da9 + true + Brep + Brep + false + 0 + + + + + + 92 + 132 + 50 + 24 + + + 117.58312 + 144.94077 + + + + + + 1 + + + + + 1 + {0} + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 6ffd83cc-a073-46cd-8213-4c0663708aa7 + Panel + + false + 1 + 99e48b23-64d9-4e2f-859d-62348fa491ae + 1 + Double click to edit panel content… + + + + + + 731 + 203 + 494 + 251 + + 0 + 0 + 0 + + 731.9958 + 203.22206 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 5262b483-9441-440a-a74d-8b235aad399d + Panel + + false + 1 + 0 + Double click to edit panel content… + + + + + + 494 + 71 + 343 + 118 + + 0 + 0 + 0 + + 494.05792 + 71.25596 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 6f2c8a4b-d787-4606-9170-900f972641c6 + true + Custom Preview + Preview + + + + + + + 473 + 320 + 48 + 44 + + + 507 + 342 + + + + + + Geometry to preview + true + 43f69636-7c49-4472-9329-bd25ec713d12 + true + Geometry + G + false + d9399b7b-ece0-4d60-ba8e-0bb8c0bdf01a + 1 + + + + + + 475 + 322 + 17 + 20 + + + 485 + 332 + + + + + + + + The material override + e22d7711-ceb9-48df-9270-b376fcd13ae6 + true + Material + M + false + b14c32be-c541-4fae-93c2-449d7543457e + 1 + + + + + + 475 + 342 + 17 + 20 + + + 485 + 352 + + + + + + 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 + 53c99f0b-499f-4471-9227-acc96558bfea + true + Custom Preview + Preview + + + + + + + 473 + 382 + 48 + 44 + + + 507 + 404 + + + + + + Geometry to preview + true + 525f46ad-33c4-44dc-8862-35b0ddce4d1d + true + Geometry + G + false + 8051ced1-c685-4aac-b373-3da1f25a7345 + 1 + + + + + + 475 + 384 + 17 + 20 + + + 485 + 394 + + + + + + + + The material override + 2e7559ef-c4d5-4ffe-a304-c34c078e5af0 + true + Material + M + false + fc5dba97-2c1a-4749-9c61-3f88abff00ff + 1 + + + + + + 475 + 404 + 17 + 20 + + + 485 + 414 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + b14c32be-c541-4fae-93c2-449d7543457e + true + Colour Swatch + Swatch + false + 0 + + 255;128;0;255 + + + + + + + 369 + 343 + 88 + 20 + + + 369.056 + 343.67847 + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 254a4a2f-d415-488e-9851-4a763f1ba58f + true + Button + dump! + false + 0 + + + + + + 41 + 187 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 77c76654-6be3-4843-b564-afe44705740d + true + File Path + Path + false + 0 + + + + + + 94 + 105 + 50 + 24 + + + 119.05513 + 117.20451 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 86bc59e0-752b-48c2-b3e8-8f0c8b9737a3 + true + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 44 + 161 + 102 + 20 + + 0 + 0 + 0 + + 44.200005 + 161.50002 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + fc5dba97-2c1a-4749-9c61-3f88abff00ff + true + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 369 + 405 + 88 + 20 + + + 369.17673 + 405.9497 + + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + f2ae36bd-8b62-496c-ac97-17ab79c53f42 + Custom Preview + Preview + + + + + + + 590 + 220 + 48 + 44 + + + 624 + 242 + + + + + + Geometry to preview + true + 85ca540e-0ffd-46e5-b014-a0ddacc0562b + Geometry + G + false + 0 + + + + + + 592 + 222 + 17 + 20 + + + 602 + 232 + + + + + + + + The material override + 6d95716c-757a-4c8f-8bb0-1685e7e04a52 + Material + M + false + 83adf7c8-580d-4af6-a713-84bf5f8bd2d3 + 1 + + + + + + 592 + 242 + 17 + 20 + + + 602 + 252 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 83adf7c8-580d-4af6-a713-84bf5f8bd2d3 + true + Colour Swatch + Swatch + false + 0 + + 255;255;0;0 + + + + + + + 465 + 242 + 88 + 20 + + + 465.53714 + 242.746 + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + 39d914fb-05fc-4c33-93a8-98326df3e596 + true + Brep + Brep + false + 0 + + + + + + 159 + 848 + 50 + 24 + + + 184.61072 + 860.9274 + + + + + + 1 + + + + + 6 + {0} + + + + + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 + + + + + 322f4e22-d195-435e-b290-052cb2318277 + + + + + aa56315b-2905-4049-8c41-0cc8b39d864b + + + + + 7fc04154-255a-413f-a8a1-6ea034e1e779 + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + aeae5255-2a74-4040-9e44-e3aedf934485 + + + + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 + true + File Path + Path + false + 0 + + + + + + 159 + 822 + 50 + 24 + + + 184.87698 + 834.0722 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\__TEMP\test\ + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 66637ff1-037c-4e4c-ba3a-0930de00a3ea + true + Button + dump! + false + 0 + + + + + + 106 + 761 + 102 + 22 + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 66ce41af-42cf-48a0-871c-5d06b68b6ae7 + true + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 111 + 795 + 102 + 20 + + 0 + 0 + 0 + + 111.36775 + 795.778 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + 649b3c81-ba59-413f-ad42-15bca79f15e2 + true + Custom Preview + Preview + + + + + + + 602 + 839 + 48 + 44 + + + 636 + 861 + + + + + + Geometry to preview + true + 799c43bc-4b78-4d8f-a2ed-f604ed2b1ddb + true + Geometry + G + false + 86cd065e-41a3-4149-9a68-e3130b58ce76 + 1 + + + + + + 604 + 841 + 17 + 20 + + + 614 + 851 + + + + + + + + The material override + 07e88719-b77c-4ac3-a12c-cc329aefe255 + true + Material + M + false + c0aa2559-2d8c-481d-a41d-c02943a5f981 + 1 + + + + + + 604 + 861 + 17 + 20 + + + 614 + 871 + + + + + + 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 + 4d39988a-2c7d-4bb0-9261-f460ec916be1 + true + Custom Preview + Preview + + + + + + + 603 + 886 + 48 + 44 + + + 637 + 908 + + + + + + Geometry to preview + true + 8d9e002d-b2f2-4476-8f21-adea36efcb4a + true + Geometry + G + false + c60f388a-008e-4a06-9770-68a2fa0520e7 + 1 + + + + + + 605 + 888 + 17 + 20 + + + 615 + 898 + + + + + + + + The material override + 58e8f37f-40e5-4060-83b0-c395fb2daf6d + true + Material + M + false + 28b353a5-44f7-436e-8a36-957623e89dde + 1 + + + + + + 605 + 908 + 17 + 20 + + + 615 + 918 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + c0aa2559-2d8c-481d-a41d-c02943a5f981 + true + Colour Swatch + Swatch + false + 0 + + 255;128;0;255 + + + + + + + 478 + 863 + 88 + 20 + + + 478.32407 + 863.82697 + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 28b353a5-44f7-436e-8a36-957623e89dde + true + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 480 + 911 + 88 + 20 + + + 480.05487 + 911.1751 + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 0bc1d704-d9a5-496a-8097-0e77a2179817 + true + true + false + true + DFXMLExporter + XMLout + 1 + + false + false + false + + + + + + 291 + 1184 + 171 + 84 + + + 398 + 1226 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + ff7bc6fc-cd70-4c56-8f79-fc4cbd06681c + true + i_dump + i_dump + true + 0 + true + 508c9c16-1d49-4404-84cc-7cc48c8f273b + 1 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 293 + 1186 + 90 + 20 + + + 339.5 + 1196 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + eac6f337-07dc-4148-804b-ee5f29e1c0f7 + true + i_assembly_name + i_assembly_name + true + 0 + true + a170d6d1-471e-4c64-9806-444e47f21d66 + 1 + The name of the assembly to export. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 293 + 1206 + 90 + 20 + + + 339.5 + 1216 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 0341be27-157c-4fa0-8841-4876c4aa61b9 + true + i_export_dir + i_export_dir + true + 0 + true + 3f1b8093-20ad-4b03-90b2-110f234137fc + 1 + The directors where to export the xml file. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 293 + 1226 + 90 + 20 + + + 339.5 + 1236 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== + + f7f134be-ff73-4607-8432-4027726d7c9a + true + i_breps + i_breps + true + 1 + true + f6905f9e-831e-4c85-831f-4a85822df09c + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 293 + 1246 + 90 + 20 + + + 339.5 + 1256 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 63fce5d6-5cca-4c37-978e-16ad72dccdf6 + true + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 413 + 1186 + 47 + 26 + + + 436.5 + 1199.3334 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + d876ac7a-afbf-4696-a6c0-6b8d5230d058 + true + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 413 + 1212 + 47 + 27 + + + 436.5 + 1226 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + cd81b022-0563-4d70-8ad2-86542a5f5a10 + true + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 413 + 1239 + 47 + 27 + + + 436.5 + 1252.6667 + + + + + + + + + + false + IyEgcHl0aG9uMwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKaW1wb3J0IG9zCmltcG9ydCB0eXBpbmcKCmltcG9ydCBkaWZmQ2hlY2sKCmltcG9ydCBkaWZmQ2hlY2submV3bW9kdWxlCmRpZmZDaGVjay5uZXdtb2R1bGUudGVzdF9uZXdfbWRvdWxlKCkKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICAiIiIKICAgICAgICBNYWluIGZ1bmN0aW9uIHRvIHRlc3QgdGhlIHBhY2thZ2UKICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAiIiIKICAgICMgYmVhbXMKICAgIGJlYW1zID0gW10KICAgIGZvciBicmVwIGluIGlfYnJlcHM6CiAgICAgICAgYmVhbSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICBiZWFtcy5hcHBlbmQoYmVhbSkKCiAgICAjIGFzc2VtYmx5CiAgICBhc3NlbWJseTEgPSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcy5ERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgIyBkdW1wIHRoZSB4bWwKICAgIHhtbDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICBpZiBpX2R1bXA6CiAgICAgICAgYXNzZW1ibHkxLmR1bXBfeG1sKHhtbCwgaV9leHBvcnRfZGlyKQogICAgb194bWwgPSB4bWwKCiAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgIG9fam9pbnRzID0gW2pmLnRvX2JyZXAoKSBmb3IgamYgaW4gYXNzZW1ibHkxLmFsbF9qb2ludF9mYWNlc10KICAgIG9fc2lkZXMgPSBbc2YudG9fYnJlcCgpIGZvciBzZiBpbiBhc3NlbWJseTEuYWxsX3NpZGVfZmFjZXNdCg== + S + + + + + *.*.python + 3.* + + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + f6905f9e-831e-4c85-831f-4a85822df09c + true + Brep + Brep + false + 0 + + + + + + 214 + 1246 + 50 + 24 + + + 239.74905 + 1258.8203 + + + + + + 1 + + + + + 6 + {0} + + + + + ba3151fb-3a8e-46c1-bdba-27ad41a4d1a2 + + + + + aa56315b-2905-4049-8c41-0cc8b39d864b + + + + + 322f4e22-d195-435e-b290-052cb2318277 + + + + + 7fc04154-255a-413f-a8a1-6ea034e1e779 + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + aeae5255-2a74-4040-9e44-e3aedf934485 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 508c9c16-1d49-4404-84cc-7cc48c8f273b + true + Button + dump! + false + 0 + + + + + + 161 + 1185 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 3f1b8093-20ad-4b03-90b2-110f234137fc + true + File Path + Path + false + 0 + + + + + + 214 + 1226 + 50 + 24 + + + 239.17398 + 1238.5846 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + a170d6d1-471e-4c64-9806-444e47f21d66 + true + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 161 + 1208 + 102 + 20 + + 0 + 0 + 0 + + 161.45294 + 1208.8801 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 537b0419-bbc2-4ff4-bf08-afe526367b2c + Custom Preview + + + + + Allows for customized geometry previews + true + e82c0b60-8d4c-487a-8a2a-60ccdfb2c440 + true + Custom Preview + Preview + + + + + + + 587 + 1184 + 48 + 44 + + + 621 + 1206 + + + + + + Geometry to preview + true + f483e244-6e89-4839-a140-53b2307e5305 + true + Geometry + G + false + d876ac7a-afbf-4696-a6c0-6b8d5230d058 + 1 + + + + + + 589 + 1186 + 17 + 20 + + + 599 + 1196 + + + + + + + + The material override + 5eadcdca-b596-4817-b74a-daf84cb33bba + true + Material + M + false + 1652822d-91b6-4619-a0f1-929bd813d353 + 1 + + + + + + 589 + 1206 + 17 + 20 + + + 599 + 1216 + + + + + + 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 + 1cf1d421-79da-445c-baea-160043841df5 + true + Custom Preview + Preview + + + + + + + 588 + 1231 + 48 + 44 + + + 622 + 1253 + + + + + + Geometry to preview + true + f3c7f1be-a13f-418f-bdc3-968772d68045 + true + Geometry + G + false + cd81b022-0563-4d70-8ad2-86542a5f5a10 + 1 + + + + + + 590 + 1233 + 17 + 20 + + + 600 + 1243 + + + + + + + + The material override + 14b44143-7bb4-4e4b-a0c1-8aeb245e6588 + true + Material + M + false + c217b73e-3729-4db1-951f-b5914db0d7d8 + 1 + + + + + + 590 + 1253 + 17 + 20 + + + 600 + 1263 + + + + + + 1 + + + + + 1 + {0} + + + + + + 255;221;160;221 + + + 255;66;48;66 + + 0.5 + + 255;255;255;255 + + 0 + + + + + + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + 1652822d-91b6-4619-a0f1-929bd813d353 + true + Colour Swatch + Swatch + false + 0 + + 255;128;0;255 + + + + + + + 484 + 1209 + 88 + 20 + + + 484.3444 + 1209.1941 + + + + + + + + + + 9c53bac0-ba66-40bd-8154-ce9829b9db1a + Colour Swatch + + + + + Colour (palette) swatch + c217b73e-3729-4db1-951f-b5914db0d7d8 + true + Colour Swatch + Swatch + false + 0 + + 255;102;255;0 + + + + + + + 485 + 1256 + 88 + 20 + + + 485.70688 + 1256.2388 + + + + + + + + + + 719467e6-7cf5-4848-99b0-c5dd57e5442c + 066d0a87-236f-4eae-a0f4-9e42f5327962 + Python 3 Script + + + + + + true + true + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== + + 0ee66d25-d08b-438a-a320-7d5b9c94eb52 + true + true + true + true + Python 3 Script + Py3 + 1 + + false + false + true + + + + + + 741 + 741 + 72 + 44 + + + 770 + 763 + + + + + + 2 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 2 + 3ede854e-c753-40eb-84cb-b48008f14fd4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 304ad97a-0eb9-4b5e-b99c-67c7dc5cf217 + true + x + x + true + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 743 + 743 + 12 + 20 + + + 750.5 + 753 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 4d5c2100-1520-4ea1-bb18-50d5e8b0298a + true + y + y + true + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 743 + 763 + 12 + 20 + + + 750.5 + 773 + + + + + + + + The execution information, as output and error streams + 968967a6-00d1-4d3d-b3ad-6c70cfd8eb1b + true + out + out + false + 0 + + + + + + 785 + 743 + 26 + 20 + + + 798 + 753 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + a527438a-a4ac-4f54-9476-6d7db1e76864 + true + a + a + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 785 + 763 + 26 + 20 + + + 798 + 773 + + + + + + + + + + aW1wb3J0IHN5cw0KDQpwcmludChzeXMuZXhlY3V0YWJsZSk= + Py3 + + + + + *.*.python + 3.* + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + 27b8206c-38aa-46d8-a4b0-7b5ce810d60a + true + Panel + + false + 0 + 968967a6-00d1-4d3d-b3ad-6c70cfd8eb1b + 1 + Double click to edit panel content… + + + + + + 1063 + 752 + 613 + 192 + + 0 + 0 + 0 + + 1063.0818 + 752.3753 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + e074f5dc-5825-470f-9d04-403633051d0e + true + Panel + + false + 1 + 109ec47e-a6f8-4875-8368-b724abf2abe2 + 1 + Double click to edit panel content… + + + + + + 679 + 763 + 484 + 241 + + 0 + 0 + 0 + + 679.09973 + 763.01855 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 719467e6-7cf5-4848-99b0-c5dd57e5442c + 066d0a87-236f-4eae-a0f4-9e42f5327962 + Python 3 Script + + + + + + true + true + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABCxJREFUSEvdlF1MW2UcxvHCZMbEKNFUo7I5NnRjDHpOe9oOEGETxWWuMXpr9MIlOgqjsDG+xgoYLxZj9GahH7RjhY5BWRnlY3y24tgX4saIVJ0rzN1pHPMjxOh7Hv/vOacQLmtMTHySf9om7/t7nz7neU/KfyrhYFuW3uZy6w86Y3qb++fsMvdfOTbvj3q7PybaO5xSZddz2tLkJZQ68wl8L6fU3Zpd5lkWDvkgHDoFAkOsDMBwpBuGyjN/CLXBp7QtySnH5mrm7vl3ocznEe1+gvthOHxWhdMYa0IwHA01KhuSld7mcVIkK/qyU2F9RedKwrWxOgjj0XM0vZBq+yHVh/3aluQk2HxVQvnpiFDZSROgORsxVvdExMM9f3LnUh3BG4bogKHkDhDtrY8b7G3PGuyB9VN3ThmxJvSTVD8AE8FNjSOQHON+ecmazpasbnlx3xF5vjhVQ62XvtT1hr6s7YpQ0Q6xKkBzhvLugqG6R42kpo/cDipgqYE+CW52TEBqmvTLd60W3N4HfFsCzO9ZxlzeYxpWFXcs2Dy/CRWn1YZwsPIgOZxnfV6DD6vOj48RfFI5wNQc9cjf781H7FXg5m5gtgDy5V21GloVVdCtOk40hMD8YXLXPOvVSEZV500RWJqjsLRMwdQyVSLHit/HjSJg5kXgkgUsKk5raFViZcf1VddKS3ph5K4TcXDnBDcfHyf4ZAK8Ymmect2ZfjOVzRbextU8YNoMRAxgF7LuASkPaHiKqKrrdxVMWdfyrAdgbBhcNDVeOPD2p/5Cb1/LW94wn4/Uod/zF98pYjf3fIzZ/GVcyQWmJGBCAEZ2AuHtgHfjBg1P/6C6+wfFsRaHoTa8UvRhn46acYLmF9yxQpml/cCtvVDynqO8v1QjwedGYFwPDGcB/S+ABbd8p6FVidWhMakurGZNGZuOjXiwZM1bBfNZfJ1a8hrwdTFwvRC4lq9GEiX4aDYwtAPoex7oSQcCaT4NrcpUP1CeeIhmaojJMVZCzj9bhcepgt8oFQS+eglK3hcJPimqkQxmAqEMoHsz0JkGuV23Q0OrMld0PWQ8NnxXOcAxDotjYjdb2u9U4IlIqILsWoHMLuXKLCLJbEyQ2dBOmZ3fLrNghswCm2TW/syC7NG9q2HXS2ocfMTkmPjA3BRtz22aymRxOoDDeSRUQXY171dt6b8jtvCKE/Mvq5HwvCkSFhHjbDQrzsKZcda3Nc660+OsI+0TbUtyYnNFTn4rlQp+YVrLu38bWG/Gfda12cU6nr7PfLp/9jaVZwrew+VdVEHq9zj1e4hXcBvQuxUssNHJ1zDvky65NbVc2ZCsMFmwgUUNCxjLWatgcAuvIJiPnLt1LnYy9YZ8QvewtiV5YUZ8kG7lARbKGGDdm25RJCsUSYw5nwjLJx8thTdl7bb+T5WS8jfirxG8xR5eUAAAAABJRU5ErkJggg== + + 82cff84c-8203-4d2d-a1d0-814c858ec33d + true + true + true + true + Python 3 Script + Py3 + 1 + + false + false + true + + + + + + 171 + 1 + 101 + 44 + + + 229 + 23 + + + + + + 1 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 2 + 3ede854e-c753-40eb-84cb-b48008f14fd4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + 1 + true + Converts to collection of Breps (Boundary REPresentations) + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + 08532ae2-a7b8-4bcb-ba9f-c6a7a22fe36f + true + i_breps + i_breps + true + 1 + true + 0f309845-29e6-43ae-b255-cdb5c2d13da9 + 1 + + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 173 + 3 + 41 + 40 + + + 195 + 23 + + + + + + + + The execution information, as output and error streams + e73efe6e-ad59-49eb-837e-2c03904e0016 + true + out + out + false + 0 + + + + + + 244 + 3 + 26 + 20 + + + 257 + 13 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + f4b0de2e-fef0-4b9d-876f-55b17adececd + true + a + a + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 244 + 23 + 26 + 20 + + + 257 + 33 + + + + + + + + + + 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 + Py3 + + + + + *.*.python + 3.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 4de40153-0a75-4628-b563-344d5ffd67b3 + true + true + false + true + DFXMLExporter + XMLout + 1 + + false + false + true + + + + + + 269 + 779 + 171 + 84 + + + 376 + 821 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 4 + 3ede854e-c753-40eb-84cb-b48008f14fd4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + d2a467a2-6e5c-4d7d-ab29-b4f069e2f8fa + true + i_dump + i_dump + true + 0 + true + 66637ff1-037c-4e4c-ba3a-0930de00a3ea + 1 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 271 + 781 + 90 + 20 + + + 317.5 + 791 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 1a5dae8c-fb00-417f-93e7-28d577f4f02e + true + i_assembly_name + i_assembly_name + true + 0 + true + 66ce41af-42cf-48a0-871c-5d06b68b6ae7 + 1 + The name of the assembly to export. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 271 + 801 + 90 + 20 + + + 317.5 + 811 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 00cdf837-c7db-48a9-83e1-57e3739e8261 + true + i_export_dir + i_export_dir + true + 0 + true + 5238ab80-c5e8-4c25-b453-6fecfe57f6f1 + 1 + The directors where to export the xml file. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 271 + 821 + 90 + 20 + + + 317.5 + 831 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== + + d4f34513-7e3b-44d3-a110-13f6f2645a98 + true + i_breps + i_breps + true + 1 + true + 39d914fb-05fc-4c33-93a8-98326df3e596 + 1 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 271 + 841 + 90 + 20 + + + 317.5 + 851 + + + + + + + + The execution information, as output and error streams + 109ec47e-a6f8-4875-8368-b724abf2abe2 + true + out + out + false + 0 + + + + + + 391 + 781 + 47 + 20 + + + 414.5 + 791 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 660dadfd-116c-4c27-a8a3-cecab444fb7a + true + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 391 + 801 + 47 + 20 + + + 414.5 + 811 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 86cd065e-41a3-4149-9a68-e3130b58ce76 + true + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 391 + 821 + 47 + 20 + + + 414.5 + 831 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + c60f388a-008e-4a06-9770-68a2fa0520e7 + true + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 391 + 841 + 47 + 20 + + + 414.5 + 851 + + + + + + + + + + false + IyEgcHl0aG9uMwojIHI6IGRpZmZDaGVjaz09MC4wLjgKCgppbXBvcnQgU3lzdGVtCmltcG9ydCB0eXBpbmcKCmltcG9ydCBSaGlubwppbXBvcnQgUmhpbm8uR2VvbWV0cnkgYXMgcmcKCmZyb20gZ2hweXRob25saWIuY29tcG9uZW50YmFzZSBpbXBvcnQgZXhlY3V0aW5nY29tcG9uZW50IGFzIGNvbXBvbmVudAoKaW1wb3J0IGRpZmZDaGVjawpmcm9tIGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzIGltcG9ydCBERkJlYW0sIERGQXNzZW1ibHkKCgpjbGFzcyBERlhNTEV4cG9ydGVyKGNvbXBvbmVudCk6CiAgICBkZWYgUnVuU2NyaXB0KHNlbGYsCiAgICAgICAgICAgIGlfZHVtcDogYm9vbCwKICAgICAgICAgICAgaV9hc3NlbWJseV9uYW1lLAogICAgICAgICAgICBpX2V4cG9ydF9kaXIsCiAgICAgICAgICAgIGlfYnJlcHM6IFN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLklMaXN0W1JoaW5vLkdlb21ldHJ5LkJyZXBdKToKICAgICAgICAiIiIKICAgICAgICAgICAgVGhpcyByZWFkIGJyZXBzIGZyb20gUmhpbm8sIGNvbnZlcnRzIHRoZW0gdG8gREZCZWFtcyBhbmQgREZBc3NlbWJsaWVzLCBhbmQgZXhwb3J0cyB0aGVtIHRvIFhNTC4KICAgICAgICAgICAgCiAgICAgICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAgICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgICIiIgogICAgICAgICMgYmVhbXMKICAgICAgICBiZWFtczogdHlwaW5nLkxpc3RbREZCZWFtXSA9IFtdCiAgICAgICAgZm9yIGJyZXAgaW4gaV9icmVwczoKICAgICAgICAgICAgYmVhbSA9IERGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICAgICAgYmVhbXMuYXBwZW5kKGJlYW0pCgogICAgICAgICMgYXNzZW1ibHkKICAgICAgICBhc3NlbWJseTEgPSBERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgICAgICMgZHVtcCB0aGUgeG1sCiAgICAgICAgeG1sOiBzdHIgPSBhc3NlbWJseTEudG9feG1sKCkKICAgICAgICBpZiBpX2R1bXA6CiAgICAgICAgICAgIGFzc2VtYmx5MS5kdW1wX3htbCh4bWwsIGlfZXhwb3J0X2RpcikKICAgICAgICBvX3htbCA9IHhtbAoKICAgICAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgICAgICBvX2pvaW50cyA9IFtqZi50b19icmVwKCkgZm9yIGpmIGluIGFzc2VtYmx5MS5hbGxfam9pbnRfZmFjZXNdCiAgICAgICAgb19zaWRlcyA9IFtzZi50b19icmVwKCkgZm9yIHNmIGluIGFzc2VtYmx5MS5hbGxfc2lkZV9mYWNlc10KCiAgICAgICAgcmV0dXJuIG9feG1sLCBvX2pvaW50cywgb19zaWRlcw== + S + + + + + *.*.python + 3.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + DFXMLExporter + + + + + + true + 2 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABg2lDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT8TJcEDC1OIWGyhVgqiopYSxSAoSIzgVbi7MVHIbsJugo2lYCtYeDRehY21tha2giB4gFhbWCnaiKz/bIQEIYIDw3y8mfeYeQOBg4xpudXdYNl5Jx6LajOzc1romWpC1DFAWDfd3MTUaIKK4+OWKrXedKks/jcakkuuCVWa8JCZc/LCi8L9q/mc4h3hiLmsJ4VPhTsduaDwvdKNIr8oTvscUJkRJxEfFo4Ia+kyNsrYXHYs4T7htqRlS35gpshJxWuKrUzB/LmnemH9kj09pXSZrcQYY4JJNAwKrJAhT5estigucdmPVvC3+P5JcRniWsEUxwhZLHTfj/qD3926qd6eYlJ9FGqePO+tHUJb8LXpeZ+Hnvd1BMFHuLBL/uwBDL6LvlnS2vahcR3OLkuasQ3nG9D8kNMd3ZeCMgOpFLyeyDfNQtM11M4Xe/vZ5/gOEtLV+BXs7kFHWrIXKrw7XN7bn2f8/oh+A2ixcqM29OAgAAAACXBIWXMAAC4iAAAuIgGq4t2SAAAAB3RJTUUH6AQHCzcfT87vFgAAAEZJREFUSEu1yKEBADAIwDCO5n/2QGQnYjJze18xS8wSs8QsMUvMErPELDFLzBKzxCwxS8wSs8QsMUvMErPELDFLzBIzs/cABgWAzBU/nmQAAAAASUVORK5CYII= + + 180538b6-48a7-45a7-9f63-4236e4b1aade + true + true + false + true + DFXMLExporter + XMLout + 1 + + false + false + false + + + + + + 288 + 1080 + 171 + 84 + + + 395 + 1122 + + + + + + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 3 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + + + + + true + Press button to export xml + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + ee32ac69-2980-466c-a27d-24c46e0f978d + true + i_dump + i_dump + true + 0 + true + 0 + Press button to export xml + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 290 + 1082 + 90 + 20 + + + 336.5 + 1092 + + + + + + + + true + The name of the assembly to export. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 7937e977-a894-475a-9126-ab9f2badf263 + true + i_assembly_name + i_assembly_name + true + 0 + true + 0 + The name of the assembly to export. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 290 + 1102 + 90 + 20 + + + 336.5 + 1112 + + + + + + + + true + The directors where to export the xml file. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 5b90a98b-2119-45b1-9acc-86618952952a + true + i_export_dir + i_export_dir + true + 0 + true + 0 + The directors where to export the xml file. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 290 + 1122 + 90 + 20 + + + 336.5 + 1132 + + + + + + + + 1 + true + The breps of the structure. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== + + b2b35e86-d097-457c-8dd0-fa8f391f2d52 + true + i_breps + i_breps + true + 1 + true + 0 + The breps of the structure. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 290 + 1142 + 90 + 20 + + + 336.5 + 1152 + + + + + + + + false + The string of xml to be exported. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + dae952a3-80b5-46b4-83e6-d4a74502350d + true + o_xml + o_xml + false + 0 + true + 0 + The string of xml to be exported. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 410 + 1082 + 47 + 26 + + + 433.5 + 1095.3334 + + + + + + + + false + The breps of the faces belonging to joints. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + f9949a62-8862-4f11-9b42-5d9d2d9760da + true + o_joints + o_joints + false + 0 + true + 0 + The breps of the faces belonging to joints. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 410 + 1108 + 47 + 27 + + + 433.5 + 1122 + + + + + + + + false + The breps of the faces belonging to sides. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 5c203e94-0aef-400c-8aec-d20d76f0571e + true + o_sides + o_sides + false + 0 + true + 0 + The breps of the faces belonging to sides. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 410 + 1135 + 47 + 27 + + + 433.5 + 1148.6667 + + + + + + + + + + false + IyEgcHl0aG9uMwoKaW1wb3J0IFJoaW5vCmltcG9ydCBSaGluby5HZW9tZXRyeSBhcyByZwoKaW1wb3J0IG9zCmltcG9ydCB0eXBpbmcKCmltcG9ydCBkaWZmQ2hlY2sKCmltcG9ydCBkaWZmQ2hlY2submV3bW9kdWxlCmRpZmZDaGVjay5uZXdtb2R1bGUudGVzdF9uZXdfbWRvdWxlKCkKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICAiIiIKICAgICAgICBNYWluIGZ1bmN0aW9uIHRvIHRlc3QgdGhlIHBhY2thZ2UKICAgICAgICA6cGFyYW0gaV9icmVwczogbGlzdCBvZiBicmVwcwogICAgICAgIDpwYXJhbSBpX2V4cG9ydF9kaXI6IGRpcmVjdG9yeSB0byBleHBvcnQgdGhlIHhtbAogICAgICAgIDpwYXJhbSBpX2R1bXA6IHdoZXRoZXIgdG8gZHVtcCB0aGUgeG1sCiAgICAiIiIKICAgICMgYmVhbXMKICAgIGJlYW1zID0gW10KICAgIGZvciBicmVwIGluIGlfYnJlcHM6CiAgICAgICAgYmVhbSA9IGRpZmZDaGVjay5kZl9nZW9tZXRyaWVzLkRGQmVhbS5mcm9tX2JyZXAoYnJlcCkKICAgICAgICBiZWFtcy5hcHBlbmQoYmVhbSkKCiAgICAjIGFzc2VtYmx5CiAgICBhc3NlbWJseTEgPSBkaWZmQ2hlY2suZGZfZ2VvbWV0cmllcy5ERkFzc2VtYmx5KGJlYW1zLCBpX2Fzc2VtYmx5X25hbWUpCgogICAgIyBkdW1wIHRoZSB4bWwKICAgIHhtbDogc3RyID0gYXNzZW1ibHkxLnRvX3htbCgpCiAgICBpZiBpX2R1bXA6CiAgICAgICAgYXNzZW1ibHkxLmR1bXBfeG1sKHhtbCwgaV9leHBvcnRfZGlyKQogICAgb194bWwgPSB4bWwKCiAgICAjIHNob3cgdGhlIGpvaW50L3NpZGUgZmFjZXMKICAgIG9fam9pbnRzID0gW2pmLnRvX2JyZXAoKSBmb3IgamYgaW4gYXNzZW1ibHkxLmFsbF9qb2ludF9mYWNlc10KICAgIG9fc2lkZXMgPSBbc2YudG9fYnJlcCgpIGZvciBzZiBpbiBhc3NlbWJseTEuYWxsX3NpZGVfZmFjZXNdCg== + S + + + + + *.*.python + 3.* + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + ef4234f1-74d1-42d5-8449-ae68033cb1a1 + true + Button + + false + 0 + + + + + + 35 + 235 + 66 + 22 + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + 07b41f33-b1e8-491e-82ae-3da0f5326222 + true + Brep + Brep + false + 0 + + + + + + 61 + 342 + 50 + 24 + + + 86.79881 + 354.94077 + + + + + + 1 + + + + + 1 + {0} + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + d89a87be-095f-41ba-bcfa-14a27b69959f + true + Button + dump! + false + 0 + + + + + + 10 + 397 + 102 + 22 + + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + 78f00f3a-c6ac-40ac-9725-ad949c6e7593 + true + File Path + Path + false + 0 + + + + + + 63 + 315 + 50 + 24 + + + 88.27081 + 327.20453 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + c4486e03-f65b-4cbb-aaea-81fdbdcd7cf0 + true + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 13 + 371 + 102 + 20 + + 0 + 0 + 0 + + 13.415691 + 371.5 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + f98c6a9b-86ca-429d-8692-dcc245c0e6e5 + true + Panel + + false + 0 + 0 + diffCheck + + + + + + -13 + 263 + 113 + 38 + + 0 + 0 + 0 + + -12.635988 + 263.5192 + + + + + + + 255;213;217;232 + + true + true + false + false + false + true + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + + true + 2 + + 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 + + 08fe15ed-12b6-4c72-a8ba-350c0da17df3 + true + true + false + true + script-sync cpython + scsy-cpy + 1 + + false + false + false + + + + + + 154 + 261 + 179 + 124 + + + 269 + 323 + + + + + + 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 + 4 + 08908df5-fa14-4982-9ab2-1aa0927566aa + 08908df5-fa14-4982-9ab2-1aa0927566aa + 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. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA6xJREFUSEvVVTlLXGEUHRUHkXHfHRWXcd/3DRVcQBFUVAzaCYKC+AsGohYGDQiipYV2VpLSykawjCIuaOGCgiZFgoVmNImc3HPnPRHHLVXIgcu8ecu59557vu+z/Cs4vLy8fsgv/iLeSbwNfn5+n+fn57G+vo61tTWsrq5iZWUFy8vLWFxcxNTUFAYGBtDa2orq6mqkpqZCCrqQT61uhhfg4+PTLh/+WlhYQHl5uUZZWRlKSkpQVFSE/Px85OTkICMjQ4mTkpKQlZUFm8125e3t7TRonoU1KCjo29LSErq6urQ6RlVVlSZiksLCQuTm5ippWloaUlJSNJKTkyEJroXD7qZ6Ar6+vh/6+/t/j42NoaamBnV1dRq8ZhJ2UlxcrF1kZ2cjPT1dyRMTE7UTKe5WpPpk0HnAER0dfTM7O4uGhgYlrq+vR0tLC+bm5rC7uwsT29vbmJycREFBARwOhyaIj49HXFwcZ8Euit2UDyDar3V2dqK3t1dlYYKenh4cHR0ZtJ44ODjQd5mA5DExMQgJCbmTJBsG7T1aw8PDXSSk1pSD1R8eHhpUnnC5XPq7v7+vw2YCUQAJCQkQF14JZ5+bWgYr1X+pqKgAg4NkkpmZGSV4Cufn5+jo6MDZ2Zn+Hx8fh91uR1RUlCZhR9LFd+G2WWTy78PCwlwk5/BoRSZh+0/h4uICTU1NatORkRG9t7Ozg9jYWERGRiI0NFQHL9dcqNMWyXSZmZmp3mYwCa14c3OjHz+ESc73aVEOmaBc1D8iIoIz0ER5eXlc3ZdMMC32uqa3zUS8fpyAspjktCfdQxKCCSiPKIHg4GB9R1zFDj5KWGzUiz5m2wwuooe2JDmty2esnOR8f2hoSJ9vbW1p9ZSHnXC9yFzdMzDQZ7Var/gxHcHfiYkJ/ZidtLW16T0+o74kZ/Wnp6f6jtPpvK+eBhGJuBbuXaSgd6kdlzxJWC0tSJycnGB4eFhb5/3BwUEcHx/rs729Pa2a5OystLT0Tug81gFRxr2EFjODzjKTPAWSc2YcLOXhjAIDA6m950ompItP8uItO+DCYVCO0dFRbG5uGrTAxsaGykLvs3IhVXuLbD+F5tm9iLCzC+rNvYWLxgy6hBJymNSbFYv7EBAQoM95NsgcX95NDTil5WvulrJ93IdJSjnMquUMgL+/v24r0jXJXz0PCKtI9ZVWraysRG1trRJQ3+bmZq20vb0d3Bi7u7t1Q2xsbHz7iWaA5+vjM/e1ePuZ/B/BYvkDKff7sf0Xzw8AAAAASUVORK5CYII= + + f703fbba-ff07-4709-8112-cd955660e259 + true + btn + btn + true + 0 + true + ef4234f1-74d1-42d5-8449-ae68033cb1a1 + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 156 + 263 + 98 + 20 + + + 206.5 + 273 + + + + + + + + 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 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 0484038e-7609-494e-abc2-e4c58b9763d1 + true + packages_2_reload + packages_2_reload + true + 1 + true + f98c6a9b-86ca-429d-8692-dcc245c0e6e5 + 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 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 156 + 283 + 98 + 20 + + + 206.5 + 293 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 23c12915-418c-45d4-8a9f-82667941634f + true + i_export_dir + i_export_dir + true + 0 + true + 78f00f3a-c6ac-40ac-9725-ad949c6e7593 + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 156 + 303 + 98 + 20 + + + 206.5 + 313 + + + + + + + + 1 + true + A generic x input. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAA+RJREFUSEvVVVso5XsU3shOcr9Fg1w2uSvHXVJuiQe5ZDJvSvJE3mhy4sEpp0QuyS0e5PLAoFxeCJFSJi8k5VKSc3Dksrc5Zs70nfX99qY5Z88Y83Q6q1b7v+v3+9Za3/rW+mn+K9NZWFjcyy9+wF+Lv8xsbGy2+vr6sL6+jtXVVSwuLmJ+fh4TExMYGhpCc3MzysvLkZeXh5SUFAQFBUESOpOrWiPCM2ZlZZUvFz8NDg4iISFBeXx8PGJjYxETE4Po6GhEREQgJCREAfv7+yMsLAx2dnZ6S0vLtyaYb5rW0dHxj9HRURQVFans6MnJyUhKSsLw8DAeHh5wc3ODhYUF5ObmIjAwUHlAQAAkgEEwXhmhvmLW1ta/lJWV/dXQ0IDU1FSkpaU9Oak6PDxEd3c3ent7sbS0hNvbW/Xfz89PVSLJPQhV70xwZqbz9PT8s729HRkZGQo0PT0dmZmZWFtbg16vR2dnJyYnJ1FRUYGqqirU19fj6OhI9YdBvL292QtW8ZMR8gsT7ldJS2lpqaKFAQjORhP88vISDL65uYna2lrV6IGBAbS2tuLg4ABdXV3w8vKCs7PzZwny3gT7ZHlubm4fSkpKVFPJOQM8Zk7w4+NjjI+PY25uDisrKwp8enpaneE36WLlvr6+EBXqBfONEVoaK9n/lpiYCDrVwoaS8y/Bd3Z2VPYtLS04OztT3wTf29vD/v6+6sns7CyEZkWXVHEl2HYa6fzPrq6uHwhOCVKKIyMjMBgMZuAEGRsbQ0dHB87Pz3FxcaHO0Hp6enB9fQ0XFxelKnd3dw7qrxqJdB0aGqq0TWcQgl9dXZmBz8zMgBJmsxsbGxVVJycn2NjYUMpixdIDeHh4ICoqitN9zQAtIi9DZGQkHgPd39+ri18D7+/vR1tbG5qamlBZWYnq6mr1f3d3VwVxcnJSONILYwXkiXxRx5xOOjM7PT19Fryurk5JlZLd2tpS/AstSkmcfOmrsQcme6PVavXBwcFq/AsKCnB3d4fl5eUXg5MWZk8Vyjdn4UlFyqSK9zzEkWeTeIkV/Ai4TqdDXFzcZ4EzmwNaPHcJJUanqqgQypWqeQ6cjaV6srKy4ODgQO7NJ5kmVbyTgw+sgGPPcrkGqKipqSk1wTU1Ndje3v5H5gKq5C3K+Sgw39xFtFesgr3w8fFRQ0PPzs5WE0z5sjdcGWyoqA/29vbqDN8G6ePz29Rkb6VkQ3h4OGR9PLkMo6KBdDxmLW8AbG1t1VKUqgn+3feAphWqfucj8riTCEB+c3JyVKb5+fkoLCxEcXExuL+4FOXOy140k/F9/feb+z1/+Zv8PzKN5m9TzzRCUDHb/QAAAABJRU5ErkJggg== + + 770c2c41-936b-4563-8085-69258fb43fe4 + true + i_breps + i_breps + true + 1 + true + 07b41f33-b1e8-491e-82ae-3da0f5326222 + 1 + A generic x input. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 156 + 323 + 98 + 20 + + + 206.5 + 333 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + c87fd4ae-11b7-4647-804e-d9cf678a79b3 + true + i_assembly_name + i_assembly_name + true + 0 + true + c4486e03-f65b-4cbb-aaea-81fdbdcd7cf0 + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 156 + 343 + 98 + 20 + + + 206.5 + 353 + + + + + + + + true + Converts to collection of boolean values + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + de47b8a3-cb7b-43e4-b958-28f86271d143 + true + i_dump + i_dump + true + 0 + true + d89a87be-095f-41ba-bcfa-14a27b69959f + 1 + + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 156 + 363 + 98 + 20 + + + 206.5 + 373 + + + + + + + + false + The redirected standard output of the component scriptsync. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 99e48b23-64d9-4e2f-859d-62348fa491ae + true + stdout + stdout + false + 0 + true + 0 + The redirected standard output of the component scriptsync. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 263 + 47 + 30 + + + 307.5 + 278 + + + + + + + + false + Generic example output of the component + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAABBNJREFUSEvVVVsorWkYXshKcj6znM/n81nORCiFTFxRLtw4JFe2JDQy2pLkggunwo22K0opCZHsRHEhKWXPTBp2sazN0DPf8631r+wxe9tzNc1bb+tvrfU/z/s+7/N+n+q/Cj8TE5Mv4hP/In8S+WNhYWHxcWJiAltbW9jY2MDa2hpWVlawuLiIqakpDAwMoKGhAaWlpcjIyEBQUBBEQb+KV9V6hO+EmZlZuXjxz8nJSaSkpMhMTk5GYmIi4uPjERMTg8jISISGhkpgPz8/hIeHw8rK6s7U1PSdAeaboba1tf1jfn4elZWVsjpmenq6JCJJXFwcoqKiJGhwcDACAgJk+vv7QxBoBYZGD/UPYW5u/nN9ff1Td3c3MjMz0djYiP7+fszNzWFzcxPT09NISEiQXURERCAnJ0f+trq6itraWojiHoRUHwxwr8LPzc3ty8jICPLz85Gbm4u6ujqMjo7i6uoK19fX8rOsrAyxsbEoLCzE0dERzs/PcXh4iPHxcXh6enIW7CJBD/kihPYbFRUVqKmpkbJkZ2cjLy9P5v7+Pm5vb3F/fy+BkpKSsL29jYWFBdAMy8vLUlJ3d3fY29s/C5KPBlhjlDo5Oemqq6ul1tScEpGE2dfXB51Oh4eHB5ycnEiStrY2hISESP19fX1l9UIBeHt7Q7jwTmDW6qHFYEX1v6WmpoLJQSokypCLiookwdPTE56fn7G0tPTVkH18fKDRaODq6ipJSCi6uBbYViox+S5HR0cdwTk8WpEktOZLm+7t7UlwRk9Pz1c29fLygoeHB1xcXODg4CBJxfO9IHivEkyfw8LCpLeZJKEV6ZaXOTw8bOxgfX3dWL0iD/V3dnbmDCRRdHQ0t/szCd4Le2npbYWIzySiW5h85hZzBo+Pj3LYJH1ZPeURSsDOzk7iiO/ZwS8iVVbUi39m20zqS58rXXV1daG3txenp6cSXKvVorOzUw6U2rNjVk952AklFXPVz8AQtWq1+o5tM1taWjA2Nob29nYMDQ1hZmZGfj84OIibmxu5E8fHx7KYkpIStLa2GqvnzIRE3AWji2TQu9SO1mtubpYbysNudnbWaEfKcnZ2hsvLS1xcXODg4AA8s1g9wQMDA7kjzwLu1R4wknmWcGhZWVnS501NTcZB0orUm4u4u7uLnZ0ddHR0KMsl5eF229jYUPvXm8wQXXwQf3wgKJ3xMqk1h0lADpRVK7IIUGlv4ZxHAfPNs4ihYRfUm9VyaZQkKCVUgFmxcB+sra3l77wbxBy/f5oa4p1oWUsXiePDmAoo5VCqFncALC0t5Xkluib4m/cBQy2k+p1WTUtLk/MgAPUtLi6WlZaXl4MHY1VVFXh+FRQU8Gj4xHf1EG8H79e/37lv5Y/fyf+jUKn+AkB0rPmebpkgAAAAAElFTkSuQmCC + + 58680e01-bd51-44b8-bac4-82d9b43f37b0 + true + o_xml + o_xml + false + 0 + true + 0 + Generic example output of the component + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 293 + 47 + 30 + + + 307.5 + 308 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + d9399b7b-ece0-4d60-ba8e-0bb8c0bdf01a + true + o_joints + o_joints + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 323 + 47 + 30 + + + 307.5 + 338 + + + + + + + + false + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 8051ced1-c685-4aac-b373-3da1f25a7345 + true + o_sides + o_sides + false + 0 + true + 0 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 284 + 353 + 47 + 30 + + + 307.5 + 368 + + + + + + + + + + false + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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 inspect
import sys


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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 get_reloadable_modules(self):
        """
            Get all the reloadable modules from the sys.modules. It
            make sure to check the module spec and loader to only reload modules 
            that are actually loaded from a file or directory

            :return: The list of reloadable modules.
        """
        BUILTIN_ORIGINS = ['built-in', 'frozen']
        reloadables = []
        for m in sys.modules.values():
            if inspect.ismodule(m):
                spec = getattr(m, "__spec__", None)
                if spec:
                    if spec.origin in BUILTIN_ORIGINS \
                            or isinstance(spec.loader, importlib.machinery.SourcelessFileLoader):
                        continue
                reloadables.append(m)

        return reloadables

    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
                packages_2_reload = self.get_reloadable_modules()
                # 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:
                #                     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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            packages_2_reload: System.Collections.Generic.IList[object],
            i_export_dir,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name,
            i_dump: bool):
        """ 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(btn)

        # 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 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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* + + + + + + + + + + + c9b2d725-6f87-4b07-af90-bd9aefef68eb + 066d0a87-236f-4eae-a0f4-9e42f5327962 + script-sync cpython + + + + + + true + 2 + + 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 + + 6b67286b-4ffe-43c4-921e-806b10a83b8f + true + false + true + script-sync cpython + scsy-cpy + 1 + + false + false + false + + + + + + 236 + 527 + 173 + 124 + + + 351 + 589 + + + + + + 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 + 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. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + f694cce9-2bb5-4c5e-a912-37ca1fe650c9 + btn + btn + true + 0 + true + 37a1fdbe-f895-4bf0-a740-19a73fe2889b + 1 + Connect a button to open a file dialog to select a cpython file to run. + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 238 + 529 + 98 + 20 + + + 288.5 + 539 + + + + + + + + 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 + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 1facc5d0-c7a9-4cbb-95f5-7d3a7ef123b5 + packages_2_reload + packages_2_reload + true + 1 + true + 0 + 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 + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 238 + 549 + 98 + 20 + + + 288.5 + 559 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 6ceb5c7a-499d-4deb-9d2c-d1a955effa73 + i_export_dir + i_export_dir + true + 0 + true + bee0b3ef-7bf0-49f6-8e1d-71c7765756d0 + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 238 + 569 + 98 + 20 + + + 288.5 + 579 + + + + + + + + 1 + true + A generic x input. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAPkSURBVEhL1VVbKOV7FN7ITnK/RYNcNrkrx11SbokHuWQyb0ryRN5ocuLBKadELsktHuTywKBcXgiRUiYvJOVSknNw5LK3OWbO9J31/famOWfPGPN0OqtW+7/r9/vWWt/61vpp/ivTWVhY3MsvfsBfi7/MbGxstvr6+rC+vo7V1VUsLi5ifn4eExMTGBoaQnNzM8rLy5GXl4eUlBQEBQVBEjqTq1ojwjNmZWWVLxc/DQ4OIiEhQXl8fDxiY2MRExOD6OhoREREICQkRAH7+/sjLCwMdnZ2ektLy7cmmG+a1tHR8Y/R0VEUFRWp7OjJyclISkrC8PAwHh4ecHNzg4WFBeTm5iIwMFB5QEAAJIBBMF4Zob5i1tbWv5SVlf3V0NCA1NRUpKWlPTmpOjw8RHd3N3p7e7G0tITb21v138/PT1UiyT0IVe9McGam8/T0/LO9vR0ZGRkKND09HZmZmVhbW4Ner0dnZycmJydRUVGBqqoq1NfX4+joSPWHQby9vdkLVvGTEfILE+5XSUtpaamihQEIzkYT/PLyEgy+ubmJ2tpa1eiBgQG0trbi4OAAXV1d8PLygrOz82cJ8t4E+2R5bm5uH0pKSlRTyTkDPGZO8OPjY4yPj2Nubg4rKysKfHp6Wp3hN+li5b6+vhAV6gXzjRFaGivZ/5aYmAg61cKGkvMvwXd2dlT2LS0tODs7U98E39vbw/7+vurJ7OwshGZFl1RxJdh2Gun8z66urh8ITglSiiMjIzAYDGbgBBkbG0NHRwfOz89xcXGhztB6enpwfX0NFxcXpSp3d3cO6q8aiXQdGhqqtE1nEIJfXV2Zgc/MzIASZrMbGxsVVScnJ9jY2FDKYsXSA3h4eCAqKorTfc0ALSIvQ2RkJB4D3d/fq4tfA+/v70dbWxuamppQWVmJ6upq9X93d1cFcXJyUjjSC2MF5Il8UcecTjozOz09fRa8rq5OSZWS3draUvwLLUpJnHzpq7EHJnuj1Wr1wcHBavwLCgpwd3eH5eXlF4OTFmZPFco3Z+FJRcqkivc8xJFnk3iJFfwIuE6nQ1xc3GeBM5sDWjx3CSVGp6qoEMqVqnkOnI2lerKysuDg4EDuzSeZJlW8k4MPrIBjz3K5BqioqakpNcE1NTXY3t7+R+YCquQtyvkoMN/cRbRXrIK98PHxUUNDz87OVhNM+bI3XBlsqKgP9vb26gzfBunj89vUZG+lZEN4eDhkfTy5DKOigXQ8Zi1vAGxtbdVSlKoJ/t33gKYVqn7nI/K4kwhAfnNyclSm+fn5KCwsRHFxMbi/uBTlzsteNJPxff33m/s9f/mb/D8yjeZvU880QlAx2/0AAAAASUVORK5CYII= + + e86775bd-fb57-4402-a56b-9a1fa88b3782 + i_breps + i_breps + true + 1 + true + a126a588-53d2-4d08-977f-68deff6a42c2 + 1 + A generic x input. + 2ceb0405-fdfe-403d-a4d6-8786da45fb9d + + + + + + 238 + 589 + 98 + 20 + + + 288.5 + 599 + + + + + + + + true + rhinoscriptsyntax geometry + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + 99293e71-3a24-4bb0-a208-4748b642d47c + i_assembly_name + i_assembly_name + true + 0 + true + aedebb31-f342-420e-ac55-d80e788a157f + 1 + + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 238 + 609 + 98 + 20 + + + 288.5 + 619 + + + + + + + + true + Converts to collection of boolean values + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAOsSURBVEhL1VU5S1xhFB0VB5Fx3x0Vl3Hf9w0VXEARVFQM2gmCgvgLBqIWBg0IoqWFdlaS0spGsIwiLmjhgoImRYKFZjSJnNxz5z0Rxy1VyIHLvHnLufeee77vs/wrOLy8vH7IL/4i3km8DX5+fp/n5+exvr6OtbU1rK6uYmVlBcvLy1hcXMTU1BQGBgbQ2tqK6upqpKamQgq6kE+tboYX4OPj0y4f/lpYWEB5eblGWVkZSkpKUFRUhPz8fOTk5CAjI0OJk5KSkJWVBZvNduXt7e00aJ6FNSgo6NvS0hK6urq0OkZVVZUmYpLCwkLk5uYqaVpaGlJSUjSSk5MhCa6Fw+6megK+vr4f+vv7f4+NjaGmpgZ1dXUavGYSdlJcXKxdZGdnIz09XckTExO1EynuVqT6ZNB5wBEdHX0zOzuLhoYGJa6vr0dLSwvm5uawu7sLE9vb25icnERBQQEcDocmiI+PR1xcHGfBLordlA8g2q91dnait7dXZWGCnp4eHB0dGbSeODg40HeZgOQxMTEICQm5kyQbBu09WsPDw10kpNaUg9UfHh4aVJ5wuVz6u7+/r8NmAlEACQkJEBdeCWefm1oGK9V/qaioAIODZJKZmRkleArn5+fo6OjA2dmZ/h8fH4fdbkdUVJQmYUfSxXfhtllk8u/DwsJcJOfwaEUmYftP4eLiAk1NTWrTkZERvbezs4PY2FhERkYiNDRUBy/XXKjTFsl0mZmZqd5mMAmteHNzox8/hEnO92lRDpmgXNQ/IiKCM9BEeXl5XN2XTDAt9rqmt81EvH6cgLKY5LQn3UMSggkojyiB4OBgfUdcxQ4+Slhs1Is+ZtsMLqKHtiQ5rctnrJzkfH9oaEifb21tafWUh51wvchc3TMw0Ge1Wq/4MR3B34mJCf2YnbS1tek9PqO+JGf1p6en+o7T6byvngYRibgW7l2koHepHZc8SVgtLUicnJxgeHhYW+f9wcFBHB8f67O9vT2tmuTsrLS09E7oPNYBUca9hBYzg84ykzwFknNmHCzl4YwCAwOpvedKJqSLT/LiLTvgwmFQjtHRUWxubhq0wMbGhspC77NyIVV7i2w/hebZvYiwswvqzb2Fi8YMuoQScpjUmxWL+xAQEKDPeTbIHF/eTQ04peVr7payfdyHSUo5zKrlDIC/v79uK9I1yV89DwirSPWVVq2srERtba0SUN/m5mattL29HdwYu7u7dUNsbGx8+4lmgOfr4zP3tXj7mfwfwWL5Ayn3+7H9F88PAAAAAElFTkSuQmCC + + 5d5ec1f4-2789-47cb-b7e0-5f1023ada8b4 + i_dump + i_dump + true + 0 + true + 51a09241-6321-4d8b-bfc9-536b009c6410 + 1 + + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 238 + 629 + 98 + 20 + + + 288.5 + 639 + + + + + + + + false + The redirected standard output of the component scriptsync. + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + eba563ee-7094-4907-b35a-ee3a9d076495 + stdout + stdout + false + 0 + true + 0 + The redirected standard output of the component scriptsync. + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 366 + 529 + 41 + 60 + + + 386.5 + 559 + + + + + + + + false + Generic example output of the component + + iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAQTSURBVEhL1VVbKK1pGF7ISnI+s5zP5/NZzkQohUxcUS7cOCRXtiQ0MtqS5IILp8KNtitKKQmR7ERxISllz0wadrGszdAz3/Ot9a/sMXvbczXNW2/rb631P8/7Pu/zfp/qvwo/ExOTL+IT/yJ/EvljYWFh8XFiYgJbW1vY2NjA2toaVlZWsLi4iKmpKQwMDKChoQGlpaXIyMhAUFAQREG/ilfVeoTvhJmZWbl48c/JyUmkpKTITE5ORmJiIuLj4xETE4PIyEiEhoZKYD8/P4SHh8PKyurO1NT0nQHmm6G2tbX9Y35+HpWVlbI6Znp6uiQiSVxcHKKioiRocHAwAgICZPr7+0MQaAWGRg/1D2Fubv5zfX39U3d3NzIzM9HY2Ij+/n7Mzc1hc3MT09PTSEhIkF1EREQgJydH/ra6uora2lqI4h6EVB8McK/Cz83N7cvIyAjy8/ORm5uLuro6jI6O4urqCtfX1/KzrKwMsbGxKCwsxNHREc7Pz3F4eIjx8XF4enpyFuwiQQ/5IoT2GxUVFaipqZGyZGdnIy8vT+b+/j5ub29xf38vgZKSkrC9vY2FhQXQDMvLy1JSd3d32NvbPwuSjwZYY5Q6OTnpqqurpdbUnBKRhNnX1wedToeHhwecnJxIkra2NoSEhEj9fX19ZfVCAXh7e0O48E5g1uqhxWBF9b+lpqaCyUEqJMqQi4qKJMHT0xOen5+xtLT01ZB9fHyg0Wjg6uoqSUgourgW2FYqMfkuR0dHHcE5PFqRJLTmS5vu7e1JcEZPT89XNvXy8oKHhwdcXFzg4OAgScXzvSB4rxJMn8PCwqS3mSShFemWlzk8PGzsYH193Vi9Ig/1d3Z25gwkUXR0NLf7MwneC3tp6W2FiM8koluYfOYWcwaPj49y2CR9WT3lEUrAzs5O4ojv2cEvIlVW1It/ZttM6kufK111dXWht7cXp6enElyr1aKzs1MOlNqzY1ZPedgJJRVz1c/AELVqtfqObTNbWlowNjaG9vZ2DA0NYWZmRn4/ODiIm5sbuRPHx8eymJKSErS2thqr58yERNwFo4tk0LvUjtZrbm6WG8rDbnZ21mhHynJ2dobLy0tcXFzg4OAAPLNYPcEDAwO5I88C7tUeMJJ5lnBoWVlZ0udNTU3GQdKK1JuLuLu7i52dHXR0dCjLJeXhdtvY2FD715vMEF18EH98ICid8TKpNYdJQA6UVSuyCFBpb+GcRwHzzbOIoWEX1JvVcmmUJCglVIBZsXAfrK2t5e+8G8Qcv3+aGuKdaFlLF4njw5gKKOVQqhZ3ACwtLeV5Jbom+Jv3AUMtpPqdVk1LS5PzIAD1LS4ulpWWl5eDB2NVVRV4fhUUFPBo+MR39RBvB+/Xv9+5b+WP38n/o1Cp/gJAdKz5nm6ZIAAAAABJRU5ErkJggg== + + c98a3826-db80-4996-b56f-4d6ae964153a + a + a + false + 0 + true + 0 + Generic example output of the component + 1c282eeb-dd16-439f-94e4-7d92b542fe8b + + + + + + 366 + 589 + 41 + 60 + + + 386.5 + 619 + + + + + + + + + + false + from ghpythonlib.componentbase import executingcomponent as component

import System
import System.Drawing
import System.Windows.Forms
import Rhino
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 inspect
import sys


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)}"
        }
        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, btn : bool = False):
        """
            Check if the button is pressed and load/change path script.
            
            :param btn: A boolean of the button
        """
        # check if button is pressed
        if btn is True:
            dialog = System.Windows.Forms.OpenFileDialog()
            dialog.Filter = "Python files (*.py)|*.py"
            dialog.Title = "Select a Python file"
            dialog.InitialDirectory = os.path.dirname("")
            dialog.FileName = ""
            dialog.Multiselect = False
            dialog.CheckFileExists = True
            dialog.CheckPathExists = True
            dialog.RestoreDirectory = True
            if dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK:
                self.path = dialog.FileName

        # default init stauts
        if self.path is None:
            raise Exception("script-sync::File not selected")

        # 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):
        """
            Reload all the modules (local files) in the directory of the script.

            :param directory: The directory of the script.
        """
        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 get_reloadable_packages(self):
        """
            Get all the reloadable modules from the sys.modules. It
            make sure to check the module spec and loader to only reload modules 
            that are actually loaded from a file or directory

            :return: The list of reloadable modules.
        """
        BUILTIN_ORIGINS = ['built-in', 'frozen']
        reloadables = []
        for m in sys.modules.values():
            if inspect.ismodule(m):
                spec = getattr(m, "__spec__", None)
                if spec:
                    if spec.origin in BUILTIN_ORIGINS \
                            or isinstance(spec.loader, importlib.machinery.SourcelessFileLoader):
                        continue
                reloadables.append(m)

        return reloadables

    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
                # reloadables = self.get_reloadable_packages()
                # # if packages_2_reload is not None:
                # #     if packages_2_reload.__len__() != 0:
                # #         for package in packages_2_reload:
                # #             if package in reloadables:
                # #                 importlib.reload(package)
                # for package in packages_2_reload:
                #     if package in reloadables:
                #         importlib.reload(package)

                # 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()

                # 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
                outparam = ghenv.Component.Params.Output
                outparam_names = [p.NickName for p in outparam]
                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:

            # send the error message to the vscode server
            err_json = json.dumps({"script_path": path,
                                    "guid": str(ghenv.Component.InstanceGuid),
                                    "msg": "err:" + str(e)})
            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)}"
            raise Exception(err_msg)

    def RunScript(self,
            btn: bool,
            packages_2_reload: System.Collections.Generic.IList[object],
            i_export_dir,
            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep],
            i_assembly_name,
            i_dump: bool):
        """ 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(btn)

        # 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 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]
        
        # TODO: add the conversion to datatree for nested lists and tuples
        for idx, outp in enumerate(outparam):
            # detect if the output is a list
            if type(self._var_output[idx]) == list or 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])
            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.* + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 37a1fdbe-f895-4bf0-a740-19a73fe2889b + Button + + false + 0 + + + + + + 133 + 510 + 66 + 22 + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + d9f12976-f7f0-40a9-a06e-c4e80b19529d + Panel + + false + 0 + 0 + diffCheck + + + + + + -20 + 551 + 113 + 38 + + 0 + 0 + 0 + + -19.14932 + 551.1913 + + + + + + + 255;213;217;232 + + true + true + false + false + false + true + + + + + + + + + 06953bda-1d37-4d58-9b38-4b3c74e54c8f + File Path + + + + + Contains a collection of file paths + false + All files|*.* + bee0b3ef-7bf0-49f6-8e1d-71c7765756d0 + File Path + Path + false + 0 + + + + + + 135 + 582 + 50 + 24 + + + 160.70218 + 594.44104 + + + + + + 1 + + + + + 1 + {0} + + + + + false + F:\diffCheck\temp\ + + + + + + + + + + + + + 919e146f-30ae-4aae-be34-4d72f555e7da + Brep + + + + + Contains a collection of Breps (Boundary REPresentations) + true + a126a588-53d2-4d08-977f-68deff6a42c2 + Brep + Brep + false + 0 + + + + + + 136 + 613 + 50 + 24 + + + 161.0756 + 625.8681 + + + + + + 1 + + + + + 1 + {0} + + + + + 5981a85d-0063-489b-8bd7-7a1ebe1453a7 + + + + + + + + + + + + + a8b97322-2d53-47cd-905e-b932c3ccd74e + Button + + + + + Button object with two values + False + True + 51a09241-6321-4d8b-bfc9-536b009c6410 + Button + dump! + false + 0 + + + + + + 88 + 674 + 102 + 22 + + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + aedebb31-f342-420e-ac55-d80e788a157f + Panel + + false + 0 + 0 + AssemblyTest + + + + + + 91 + 649 + 102 + 20 + + 0 + 0 + 0 + + 91.80564 + 649.3606 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + 59e0b89a-e487-49f8-bab8-b5bab16be14c + Panel + + + + + A panel for custom notes and text values + dbcb817b-1342-4c31-96a8-a828fd3f41e1 + Panel + + false + 1 + eba563ee-7094-4907-b35a-ee3a9d076495 + 1 + Double click to edit panel content… + + + + + + 509 + 403 + 494 + 251 + + 0 + 0 + 0 + + 509.25073 + 403.22205 + + + + + + + 255;213;217;232 + + true + true + true + false + false + true + + + + + + + + + + + + + + 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 + + + + + \ No newline at end of file diff --git a/src/gh/util/componentizer_cpy.py b/src/gh/util/componentizer_cpy.py new file mode 100644 index 00000000..cdffe828 --- /dev/null +++ b/src/gh/util/componentizer_cpy.py @@ -0,0 +1,408 @@ +import argparse +import base64 +import json +import os +import re +import sys +import tempfile +import urllib.request, urllib.parse, urllib.error +import zipfile +from io import BytesIO + +import clr +import System +import System.IO + + +SCRIPT_COMPONENT_GUID = System.Guid("c9b2d725-6f87-4b07-af90-bd9aefef68eb") +CPY_VER = "3.-1" +TEMPLATE_VER = re.compile("{{version}}") +TEMPLATE_NAME = re.compile("{{name}}") +TEMPLATE_GHUSER_NAME = re.compile("{{ghuser_name}}") + +TYPES_MAP = dict( + none="6a184b65-baa3-42d1-a548-3915b401de53", + ghdoc="1c282eeb-dd16-439f-94e4-7d92b542fe8b", + float="9d51e32e-c038-4352-9554-f4137ca91b9a", + bool="d60527f5-b5af-4ef6-8970-5f96fe412559", + int="48d01794-d3d8-4aef-990e-127168822244", + complex="309690df-6229-4774-91bb-b1c9c0bfa54d", + str="3aceb454-6dbd-4c5b-9b6b-e71f8c1cdf88", + datetime="09bcf900-fe83-4efa-8d32-33d89f7a3e66", + guid="5325b8e1-51d7-4d36-837a-d98394626c35", + color="24b1d1a3-ab79-498c-9e44-c5b14607c4d3", + point="e1937b56-b1da-4c12-8bd8-e34ee81746ef", + vector="15a50725-e3d3-4075-9f7c-142ba5f40747", + plane="3897522d-58e9-4d60-b38c-978ddacfedd8", + interval="589748aa-e558-4dd9-976f-78e3ab91fc77", + uvinterval="74c906f3-db02-4cea-bd58-de375cb5ae73", + box="f29cb021-de79-4e63-9f04-fc8e0df5f8b6", + transform="c4b38e4c-21ff-415f-a0d1-406d282428dd", + line="f802a8cd-e699-4a94-97ea-83b5406271de", + circle="3c5409a1-3293-4181-a6fa-c24c37fc0c32", + arc="9c80ec18-b48c-41b0-bc6e-cd93d9c916aa", + polyline="66fa617b-e3e8-4480-9f1e-2c0688c1d21b", + rectangle="83da014b-a550-4bf5-89ff-16e54225bd5d", + curve="9ba89ec2-5315-435f-a621-b66c5fa2f301", + mesh="794a1f9d-21d5-4379-b987-9e8bbf433912", + surface="f4070a37-c822-410f-9057-100d2e22a22d", + subd="20f4ca9c-6c90-4fd6-ba8a-5bf9ca79db08", + brep="2ceb0405-fdfe-403d-a4d6-8786da45fb9d", + geometrybase="c37956f4-d39c-49c7-af71-1e87f8031b26" +) + +EXPOSURE = dict(valid=set([-1, 2, 4, 8, 16, 32, 64, 128]), default=2) +ACCESS = dict(valid=set([0, 1, 2]), map=dict(item=0, list=1, tree=2), default=0) +PARAM_TYPE = dict( + valid=set(TYPES_MAP.values()), map=TYPES_MAP, default=TYPES_MAP["ghdoc"] +) +WIRE_DISPLAY = dict( + valid=set([0, 1, 2]), map=dict(default=0, faint=1, hidden=2), default=0 +) + + +def fetch_ghio_lib(target_folder="temp"): + """Fetch the GH_IO.dll library from the NuGet packaging system.""" + ghio_dll = "GH_IO.dll" + filename = "lib/net48/" + ghio_dll + + response = urllib.request.urlopen("https://www.nuget.org/api/v2/package/Grasshopper/") + dst_file = os.path.join(target_folder, ghio_dll) + zip_file = zipfile.ZipFile(BytesIO(response.read())) + + with zip_file.open(filename, "r") as zipped_dll: + with open(dst_file, "wb") as fp: + fp.write(zipped_dll.read()) + + return dst_file + + +def find_ghio_assembly(libdir): + for root, _dirs, files in os.walk(libdir): + for basename in files: + if basename.upper() == "GH_IO.DLL": + filename = os.path.join(root, basename) + return filename + + +def bitmap_from_image_path(image_path): + with open(image_path, "rb") as imageFile: + # Ensure img_string is a string, not a bytes object + img_string = base64.b64encode(imageFile.read()) + if isinstance(img_string, bytes): + img_string = img_string.decode() + + # Now you can pass img_string to the FromBase64String method + return System.Convert.FromBase64String(img_string) + # return System.Convert.FromBase64String(img_string) + + +def validate_source_bundle(source): + icon = os.path.join(source, "icon.png") + code = os.path.join(source, "code.py") + data = os.path.join(source, "metadata.json") + + if not os.path.exists(icon): + raise ValueError( + "icon missing, make sure icon.png is present in the source bundle: {}".format( + source + ) + ) + if not os.path.exists(code): + raise ValueError( + "code missing, make sure code.py is present in the source bundle: {}".format( + source + ) + ) + if not os.path.exists(data): + raise ValueError( + "metadata missing, make sure metadata.json is present in the source bundle: {}".format( + source + ) + ) + + icon = bitmap_from_image_path(icon) + + with open(code, "r") as f: + python_code = f.read() + + with open(data, "r") as f: + data = json.load(f) + + if "exposure" not in data: + data["exposure"] = EXPOSURE["default"] + + if data["exposure"] not in EXPOSURE["valid"]: + raise ValueError( + "Invalid exposure value. Accepted values are {}".format( + sorted(EXPOSURE["valid"]) + ) + ) + + ghpython = data.get("ghpython") + + if r'"""' not in python_code: + python_code = r'"""{}"""{}{}'.format( + data.get("description", "Generated by Componentizer"), + os.linesep, + python_code, + ) + + return icon, python_code, data + + +def parse_param_access(access): + try: + access = int(access) + except ValueError: + # Maybe string? + access = ACCESS["map"].get(access) + + if access not in ACCESS["valid"]: + raise ValueError( + "Invalid param access value. Valid values are {}".format( + sorted(ACCESS["valid"]) + ) + ) + + return access + + +def parse_wire_display(wire_display): + try: + wire_display = int(wire_display) + except ValueError: + wire_display = WIRE_DISPLAY["map"].get(wire_display) + + if wire_display not in WIRE_DISPLAY["valid"]: + raise ValueError( + "Invalid wire display value. Valid values are {}".format( + sorted(WIRE_DISPLAY["valid"]) + ) + ) + + return wire_display + + +def parse_param_type_hint(type_hint_id): + type_hint_id = type_hint_id or PARAM_TYPE["default"] + + if type_hint_id in TYPES_MAP: + type_hint_id = TYPES_MAP[type_hint_id] + + if type_hint_id not in PARAM_TYPE["valid"]: + raise ValueError( + 'Invalid param type hint ID ("{}"). Valid values are {}'.format( + type_hint_id, sorted(PARAM_TYPE["valid"]) + ) + ) + + try: + type_hint_id = System.Guid.Parse(type_hint_id) + except SystemError: + raise ValueError("Unable to parse type hint ID: {}".format(type_hint_id)) + + return type_hint_id + + +def replace_templates(code, version, name, ghuser_name): + if version: + code = TEMPLATE_VER.sub(version, code) + + code = TEMPLATE_NAME.sub(name, code) + code = TEMPLATE_GHUSER_NAME.sub(ghuser_name, code) + + return code + + +def create_ghuser_component(source, target, version=None, prefix=None): + from GH_IO.Serialization import GH_LooseChunk + + icon, code, data = validate_source_bundle(source) + + code = replace_templates(code, version, data["name"], os.path.basename(target)) + + instance_guid = data.get("instanceGuid") + if not instance_guid: + instance_guid = System.Guid.NewGuid() + else: + instance_guid = System.Guid.Parse(instance_guid) + + prefix = prefix or "" + + root = GH_LooseChunk("UserObject") + root.SetGuid("BaseID", SCRIPT_COMPONENT_GUID) + root.SetString("Name", prefix + data["name"]) + root.SetString("NickName", data["nickname"]) + root.SetString("Description", data.get("description", "")) + root.SetString("ToolTip", data.get("description", "")) + root.SetInt32("Exposure", data.get("exposure", EXPOSURE["default"])) + root.SetString("Category", data["category"]) + root.SetString("SubCategory", data["subcategory"]) + root.SetGuid("InstanceGuid", instance_guid) + root.SetByteArray("Icon", icon) + + ghpython_data = data["ghpython"] + + ghpython_root = GH_LooseChunk("UserObject") + ghpython_root.SetString("Description", data.get("description", "")) + bitmap_icon = System.Drawing.Bitmap.FromStream(System.IO.MemoryStream(icon)) + ghpython_root.SetDrawingBitmap("IconOverride", bitmap_icon) + ghpython_root.SetBoolean("UsingLibraryInputParam", False) + ghpython_root.SetBoolean("UsingScriptInputParam", False) + ghpython_root.SetBoolean("UsingStandardOutputParam", False) + ghpython_root.SetInt32("IconDisplay", ghpython_data.get("iconDisplay", 0)) + ghpython_root.SetString("Name", data["name"]) + ghpython_root.SetString("NickName", data["nickname"]) + ghpython_root.SetBoolean("MarshalGuids", ghpython_data.get("marshalGuids", True)) + + # ghpython_root.CreateChunk('Attributes') + # for mf in ('Bounds', 'Pivot', 'Selected'): + + params = ghpython_root.CreateChunk("ParameterData") + inputParam = ghpython_data.get("inputParameters", []) + outputParam = ghpython_data.get("outputParameters", []) + + params.SetInt32("InputCount", len(inputParam)) + for i, _pi in enumerate(inputParam): + params.SetGuid( + "InputId", i, System.Guid.Parse("08908df5-fa14-4982-9ab2-1aa0927566aa") + ) + params.SetInt32("OutputCount", len(outputParam)) + for i, _po in enumerate(outputParam): + params.SetGuid( + "OutputId", i, System.Guid.Parse("08908df5-fa14-4982-9ab2-1aa0927566aa") + ) + + for i, pi in enumerate(inputParam): + input_instance_guid = System.Guid.NewGuid() + pi_chunk = params.CreateChunk("InputParam", i) + pi_chunk.SetString("Name", pi["name"]) + pi_chunk.SetString("NickName", pi.get("nickname") or pi["name"]) + pi_chunk.SetString("Description", pi.get("description")) + pi_chunk.SetBoolean("Optional", pi.get("optional", True)) + pi_chunk.SetString("ToolTip", pi.get("description", "")) + pi_chunk.SetBoolean("AllowTreeAccess", pi.get("allowTreeAccess", True)) + pi_chunk.SetBoolean("ShowTypeHints", pi.get("showTypeHints", True)) + pi_chunk.SetInt32( + "ScriptParamAccess", + parse_param_access(pi.get("scriptParamAccess", ACCESS["default"])), + ) + pi_chunk.SetInt32("SourceCount", pi.get("sourceCount", 0)) + pi_chunk.SetGuid("InstanceGuid", input_instance_guid) + pi_chunk.SetGuid("TypeHintID", parse_param_type_hint(pi.get("typeHintID"))) + pi_chunk.SetInt32( + "WireDisplay", + parse_wire_display(pi.get("wireDisplay", WIRE_DISPLAY["default"])), + ) + pi_chunk.SetBoolean("ReverseData", pi.get("reverse", False)) + pi_chunk.SetBoolean("SimplifyData", pi.get("simplify", False)) + if pi.get("flatten", False): + pi_chunk.SetInt32("Mapping", 1) + elif pi.get("graft", False): + pi_chunk.SetInt32("Mapping", 2) + + for i, po in enumerate(outputParam): + output_instance_guid = System.Guid.NewGuid() + po_chunk = params.CreateChunk("OutputParam", i) + po_chunk.SetString("Name", po["name"]) + po_chunk.SetString("NickName", po.get("nickname") or po["name"]) + po_chunk.SetString("Description", po.get("description")) + po_chunk.SetBoolean("Optional", po.get("optional", False)) + po_chunk.SetString("ToolTip", po.get("description", "")) + po_chunk.SetInt32("SourceCount", po.get("sourceCount", 0)) + po_chunk.SetGuid("InstanceGuid", output_instance_guid) + po_chunk.SetBoolean("ReverseData", po.get("reverse", False)) + po_chunk.SetBoolean("SimplifyData", po.get("simplify", False)) + if po.get("flatten", False): + po_chunk.SetInt32("Mapping", 1) + elif po.get("graft", False): + po_chunk.SetInt32("Mapping", 2) + + script = ghpython_root.CreateChunk("Script") + + code_base64 = base64.b64encode(code.encode("utf-8")) + code_base64 = str(code_base64)[2:-1] + script.SetString("Text", code_base64) + script.SetString("Title", "S") + language_spec = script.CreateChunk("LanguageSpec") + language_spec.SetString("Taxon", "*.*.python") + language_spec.SetString("Version", CPY_VER) + + # xml_serialized = ghpython_root.Serialize_Xml() + root.SetByteArray("Object", ghpython_root.Serialize_Binary()) + System.IO.File.WriteAllBytes(target, root.Serialize_Binary()) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Create GHUser components out of python code." + ) + parser.add_argument( + "source", + type=str, + help="Source directory where code for all components is stored", + ) + parser.add_argument("target", type=str, help="Target directory for ghuser files") + parser.add_argument( + "--ghio", + type=str, + required=False, + help="Folder where the GH_IO.dll assembly is located. Defaults to ./lib", + ) + parser.add_argument( + "--version", type=str, required=False, help="Version to tag components" + ) + parser.add_argument( + "--prefix", + type=str, + required=False, + help="Add this prefix to the name of each generated component", + ) + args = parser.parse_args() + + sourcedir = args.source + if not os.path.isabs(sourcedir): + sourcedir = os.path.abspath(sourcedir) + + targetdir = args.target + if not os.path.isabs(targetdir): + targetdir = os.path.abspath(targetdir) + + if args.ghio is None: + libdir = tempfile.mkdtemp("ghio") + fetch_ghio_lib(libdir) + else: + libdir = os.path.abspath(args.ghio) + gh_io = find_ghio_assembly(libdir) + source_bundles = [ + d + for d in os.listdir(sourcedir) + if os.path.isdir(os.path.join(sourcedir, d)) + and d not in ("__pycache__", ".git") + ] + + print("GHPython componentizer") + print("======================") + + print("[x] Source: {} ({} components)".format(sourcedir, len(source_bundles))) + print("[ ] Target: {}\r".format(targetdir), end="") + if not os.path.exists(targetdir): + os.mkdir(targetdir) + print("[x]") + + if not gh_io: + print("[-] Cannot find GH_IO Assembly! Aborting.") + sys.exit(-1) + + clr.AddReference(os.path.splitext(gh_io)[0]) + + print("[x] GH_IO assembly: {}".format(gh_io)) + + print("Processing component bundles:") + for d in source_bundles: + source = os.path.join(sourcedir, d) + target = os.path.join(targetdir, d + ".ghuser") + print(" [ ] {}\r".format(d), end="") + create_ghuser_component(source, target, args.version, args.prefix) + print(" [x] {} => {}".format(d, target)) \ No newline at end of file From 456b4e7d49988dc9dff38a803afd2c4c3f791194 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 21 Apr 2024 12:25:33 +0200 Subject: [PATCH 067/141] ADD: a bunch of variations of logo --- README.md | 2 +- assets/logo/logo_pixelized.xcf | Bin 139049 -> 141833 bytes assets/logo/logo_pixelized_b.png | Bin 0 -> 25391 bytes assets/logo/logo_pixelized_bw.png | Bin 0 -> 27557 bytes assets/logo/logo_pixelized_bw.xcf | Bin 0 -> 278606 bytes assets/logo/logo_pixelized_bwg.png | Bin 0 -> 49764 bytes assets/logo/logo_pixelized_bwg.xcf | Bin 0 -> 480359 bytes assets/logo/logo_pixelized_extracolor.png | Bin 0 -> 27688 bytes assets/logo/logo_pixelized_extracolor.xcf | Bin 0 -> 124359 bytes 9 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 assets/logo/logo_pixelized_b.png create mode 100644 assets/logo/logo_pixelized_bw.png create mode 100644 assets/logo/logo_pixelized_bw.xcf create mode 100644 assets/logo/logo_pixelized_bwg.png create mode 100644 assets/logo/logo_pixelized_bwg.xcf create mode 100644 assets/logo/logo_pixelized_extracolor.png create mode 100644 assets/logo/logo_pixelized_extracolor.xcf diff --git a/README.md b/README.md index 127a1a6c..5e881a1e 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@

- +

diff --git a/assets/logo/logo_pixelized.xcf b/assets/logo/logo_pixelized.xcf index 5bf8af355abed487a3e83fabd1b3100cb7e3eb90..46e3361bc04a9ec552875dca728fb26b144181f0 100644 GIT binary patch delta 2647 zcmciEJ#W)M7{GDIPEgzlu^9#`rD=PS$d zsal^pNAEYzhmAA(zH#h#PaaA0D~UJKKav=~K3jivK2MwTn`7;dpX;$H^J(us`%}OE zvN^}zjoLn2mG~1c@mH&7-NDd zW|(8qj&Ip}B@GqU#<`0gD)ceH5F?B+!4xyhv1smJW?)`og|%_tMGqDF7+{DI#+YD= z8Rn=93ME!p8xLIcP@#_jh8SUt38t7~Zqx?_4JB4s8xLLdP@#_jh8SUt38t7~-m2}x zf`$?+tc}V=4;A_tV2BaMm|%(-=8f92Rnayym50_sVkxnb*xo~3cMmv`geH>EL=u_| zk&y0r$9)qVe2Q;MaPS1WpDDeSbscz(yOvnr;-MNc!8>`)`XqQK33RV<*Anad+Gzf< z&uDhKK2z9dr3sRuWr@|Eu@Dz*Pdy@j^StONo`lR{ruWBv$;k Td=kGv97(;9)W{4?fW@ct)X2uw=^BmTFrBAQ) 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%0ALxWm;S)8a_Z8)`@GH7^Sp~jnwxW; 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 W%dm6uk1%WkKMeig+JEf){C@#$mTxWq literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_bw.png b/assets/logo/logo_pixelized_bw.png new file mode 100644 index 0000000000000000000000000000000000000000..8f758a05174f9c8c9044a694e3a35c55a87afd6e GIT binary patch literal 27557 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

(kCYm_aN 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 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_bwg.png b/assets/logo/logo_pixelized_bwg.png new file mode 100644 index 0000000000000000000000000000000000000000..c33422423845878da90a856d0e90ad3ae117da47 GIT binary patch literal 49764 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�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 EeYZP) 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 literal 0 HcmV?d00001 diff --git a/assets/logo/logo_pixelized_extracolor.xcf b/assets/logo/logo_pixelized_extracolor.xcf new file mode 100644 index 0000000000000000000000000000000000000000..c07746165f2090b1d08c3a350c861a860da0fb89 GIT binary patch literal 124359 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 O!w70BR#9?WkNtmOd2pTp literal 0 HcmV?d00001 From 7b316c7006a53926e8bfdc5e0c37119ef05e1cb2 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sun, 21 Apr 2024 12:30:31 +0200 Subject: [PATCH 068/141] ADD: additional logos and variation --- README.md | 2 +- assets/logo/logo_pixelized.xcf | Bin 141833 -> 339361 bytes assets/logo/logo_pixelized_bwvioelt.png | Bin 0 -> 50056 bytes .../logo_pixelized_bwvioelt_background.png | Bin 0 -> 48794 bytes 4 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 assets/logo/logo_pixelized_bwvioelt.png create mode 100644 assets/logo/logo_pixelized_bwvioelt_background.png diff --git a/README.md b/README.md index 5e881a1e..62e95560 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@

- +

diff --git a/assets/logo/logo_pixelized.xcf b/assets/logo/logo_pixelized.xcf index 46e3361bc04a9ec552875dca728fb26b144181f0..d250d23d03dfe76849522a08168bc733388442f9 100644 GIT binary patch literal 339361 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 delta 4482 zcmcK8UuauZ9KiAWrH9{ReD8x~0@x?gGh=W2l z%Iy$wL4wsG*+mK#A2cgP#vVqL;=iY>D=KpjVHT0$pCDz3f(EJe=wCupka0_T46 z``vTT{oQlV$wTI^?aX{xKl`x0?ZUw}vuR4Je2hJor#j>&>dhUOg14EvZfbQ|FU;Ln zZ*IF=tNX(1WOS@zS={5pCJa@sYO%Ej*Gp&(MJ%CQs5SZ}ZVVz-G)9Tzn7|~aF@p}~ zu~5<0v__Xi5ldJW1AYvmg;9)S0+X1=3_6&{f>PaI3%DeTSi-V+yB~vSVHD$-z$B(I zBerJ6jw@os85V+?$V3lFu+07qUBpO_S%D0W$r;mzf=s%m1_#Cfb{)WVFw_-0ogonlRcZnA$q+m}-;-k03%d$PRD}xe$b+35+ zg!n^QEcr2r7E;iSF^PY3#PyP=?w9fO=IavMZR_%-`U~L^q~pos#5TSx&LqV%SH;=aM2GWl%GB!T zbCSP!KzuhWe%vCuvifz`n*m$X-Jj*eCnmllUj9bBdQtqELchcBnXy$0{zVq4{>QM_ z-|+qAW5g3EYsc`NR`;UX3qyHJhr{UFvG~ooh0U&dAvh>vrTm5Bs)-jZWD@ zhEfB-*VMpR{9t-Fq*N02QWwG0jL9{T6aZF$m)0nAfYeu(2B98@h zv4|xsi+lYTL<^%B#{?!ZjTvQSOYU_@%AF^w6vWS>JK zj|FtGh$SqGmLG#?VHD$-z$B*8&hW*-JQmRPR0p+(`&AoIZBVuKt%>a#2K1?deCm3i zD#-Ug3)=c8+VDV|De#sSQ0)7Fcru)!*^Iy<&Td z_VI>QU#*~<&f99=);fhZ4fr2_2h{XepMhIh;HCYZP) zaB^>EX>4U6ba`-PAZ2)IW&i+q+NGUamgP8-UH>_X9s=5XRVti6aCx52z(-f2c&qtd4CG%%YOb1_z`|piEa|%BrVM6}hJpK7+FrwF?=70O8 ze_55c{`u{{{QmcE$3Isq$DgmHe@t@y^Yh>S{s`sYugaeKzdbqkpTEU_{XNT@z7hRn z_Wl3+-u>P0%v;P{ndN{5 z5hBa=h8*rN!yBIc^9mP3%<(y5<1aB@ESkUUsl^em)220JoyfMH3n{`2>iGIJ^s5FysxSd!ud1#hy~+{(aB~QuAG1JHC80NKa*Pa z1pof~&wpIk#0nN?Srr*f?D}r8O8CnXq`lCIFBX1&IvCpha|5P`M;8VY5-Y%}g;YWf zXN$3gz(jTyXfkvZC@xkYloD?S8FNaNwdv7Eb4d&PtFc6WeeipX87omzMZ-EPG+C^i z3-Z%)M}}reC6`iaX{DD@W=%EMQfqBhqc~e?`Dmrp)>?0)&7OMhrPtni@1xHVN5W{9 zQAZnnj4>zAoZNYG_2dh4uDH_5s~oGYw)z@tUWm_?uX5F^UHux@yyKm2?8ja2cK3VS z^9c{4^yH^J^=VIk#xq|;?M=s<-}2VCz5N~U{IhD|M{WQ4?|);}!q2M3y;6R${aH1B z+uH9fg65>SW-M4da$v=qOMpN}*X-;e=jh70X6J}#MTrcuxMp{7#aO}ogjnA2yLLzX zR@9aI|5~@B<$qbX`2V_chfDY0T)F?eZvSr8Zr#weSM1Y5C-qEdAD=&c#y)j+|LN!P zufJIHxkE14M~rd0($nH~*8C2n?mDmcep0#mUEezHQ0A)R4TI(A`B-lne!20o&vl)5 ze)8=1J>MBHm$jyOujd+12{)$ddfxiXv*r83*{}Mp)JDBm2Skkfx$k^F&LiT&v_2s{ z$m`QeIbRm6yyaph@B3y+`<=Nyrn;Udg!g_^zk0ZjI0kRe_>i>zKJU1yH!Wl3QrpX8 z_6^1w6PX!l&3yIzuG{a;JKQm|e)l-u3lV$Yc|EC};ZC7kZ^l;VB4Fn%5{_lBV zA+8Ij-f+byk{U1@H5DqbIJ!R}$wnK5QG-z^57b)&$TbfoxX)HJS_ zb!v?TFAG41)U2Qxf@MTSE3NUoeyDQxGV@(e?Ce#!`GFl|($jkHxs#V6TE^WWmJ{Tk&S&2uU|`#gS}2^@Xoi0kzgNSxZ-FbW7k)!S z8=s8l!DSa5;C>9og*RfhwgzAW%RN`dM&*(4=_x$tcNY|U4&YV=9&p8{@`c!blh*5s0iZ9FYi?nH$-5edYGV)6co%erss;S#=$Z* zg$t`bGcSkJWC_we)7yJH3YNA849lgMaHrKUB)B+O!{fCm3QBh8#ydU%On`Kpch7AW zY+3F1tk*~w|0^v(NJk#<%H_?mt{&cAls9k!b5-68jKQoFm<>pKU`P<$gwcg}U{|mV z_W=r7=qi)aFHBj8EH_VKwl7e^Qvf~TKHL4URv2Im7uw4&k&TIf*^pv(3h!F!vv;aKbYez zqAN@|8VV|96qrxc_-X+mzVSm>*GK|6S*HQHs?U*lnYem&TzRl4FAlx`^%ko%evCUZ zL*=^9=Xx5R0=TC)L+b$0<<2NAI1N+yw)!MJGCoEmjeXtkI z0On!Fg~p=iSh9rnmx-ed6#*Zb)FGRG^-UL$P@{yNgT31g@MX2{RL~SAxUY`#z4-m> z4ebyYM}Qy9W`pGOfB$oP9t`|OKL{*N36&UO3;a=l1t=*Nrk1cE3MUc_pvTnzK}V~? z8rA^vX5JAvGydjdF65xc1b~5T@fxvtaCrLVOimfAAt-eFds|_3yziAPGpadr!?;G z^sk_vCz72bPVRAV++EHS43LZIL>%~erzTr`#hg=_Z5V* zbN<0jPyf3oy4Q;s-^s_P8`w}li>%toB%T?G#`smtTAP!Hf%GcYK}Eq-WgK5n3Nr?Z zN!Bl5kOzi4O|0sZj*%`P8qV&1p&+f`!LSlrj5-pP!Fr*`3V#{UKW4e{4CXc7ryw8W zF?i3b8PY(<=XKu~3b5egZ^LEso;(JBDpLaM8+SaI6Q*b})QU z5F*zh!rm`F1!9lVB2%YO4q$_4J0A=Sxax`6keB<+7~g(Fz7{icUq|C6H#&nXVOzQE zngdnGjUt+3;-PT|0lTQvZYhBHah}l7n%;Gyzwk{k(s|S~C*UuX=jT;eDLf?TXM*A$ zeo>>Ii5X&EhQ{`~>MLkJK|UvN`BKA={K6;jK5x^eCul-wKs-Fsi#~(OC8-N>zfZj= zO#iLO-=;OmAvO#?w>|OzC*k&WBtVCRWWHx)Rk3?mkOcS(7vGKnV^Ayb&cB=>ai{_? ze$N4Vc1*}oo#i>1xEPR27-{XRC0_=Fi$Q_1V;;GXImDka30)VO%6QNGs5^2I1PF0= z`q1l#C*CeNM!EDFeI{51?17uQF@GZ5>xTOAdYB!E{Ev@*kHi}DpJ$o;4`8s=^qfwV z;nIQQqVobb$Sc65Mc#ubZxf1FsB5`0Og7~F+873yiHz{P7u=T73%v%w7(T!%*Bnr8 zpd4=mn=4uaFjMqW@JyS>WWhVrC$(o}6GQ5A7Z5A+pJ)#}3K?>&0WeXfq%z>gBwhH7Vl-gbMkO5O=K1Nqnamx$IuMM`}! zJs<(*2yccT?JNnChPJ;A)5gWP-@FMKMl6c3f>9pO!FwCR%|&|m{JG!|XIvM~^c19w zjd9b9)j6+L@bF)V0OJp3GgN>QRlWYj#4)~xQN;m{eCPpBJy<~M(5a;lTTIh~PM(h| zSRp~LxEMzWbmQe%b9_}VxXD)+4nhJS+>l+v#jDp;*55NSbgqJi9 zAR}q19urf@3+R4tB0OIF1mMQ(XAFR{E(z>^bbvf`?5NIS0Wdot&U=dUt zBEA;KdA$#C4*-ch1Bd4DB=x8WL5~lRy}zKn`s!21JEbrm?}6Pz z0kt|(A3X@L`Nz3L%u*Z%wcGk$pS8M=CxDMm_ct)>fpw{<78n-?m5sLah(XvlWbA%%zepb2 zry+X)lMCsFukC9SQ}8xyBW6KyV1nCr)h}NMgMmd1vn-~qjQaarELX&;KRKoQxG|sM z-tUtCdKa*B3R-y>Sh_X?gzCM*h8vaOHxsf4f_tL`VAOa-Ec6Xi077=P}#$9M-o$Q0?}q(Rqr3&+yYJvVL}GJ{0|A!23vQ?c{Vg@OnS%+vOc zx!y4Mw!m2p+fd5|FB(c@x(>J+_5|(+ibwCU%#T|zJ>46i&+zcRJ1Ply`AfYBi#3Ho=HbLpekMi{xY<9P$&V+4nWD8V!Qi>&F&iV(kxB5 z4qS({@vd#(K#T+mk49?BcF1+ON5RK0P7eMCCfYYZhezTLUzGGYlny=V$w2SzNP{x@ zmm~EHvdc5Rv4II=J;%=|m@l}+at9|L3m(TPrh5S=v)hCY-1>GDzjpv1#C?a;m@p4X z0)mt`aLSU)^N24V3|2AG)K+C_4;-wr%z$|DDMkdZiFHN!f#Y?@?Tqh2|A0s66SH>p zV;YuTT9$^0g8rDajt_n^<`-Pq#YhWwfN$>nALpy~R$jh>wwSXLz{l^g?hd#67gpIY0A|IWZ$^F~Qh@5em=^E(1ti z7e*b|^WL-K2^XNVKLsvQ?hDIrB%(o2I#sgzF*aZe2JRr(dcP}qzvNNN6z$y^%3p4HnruCri z2bLBGq?X6d@|_!_;N&q6aNZ^@$wHFnnK)JL415aYY%0ceeNX56^$4s?{CWO~GvWE$ zQUUWol$tc?{Ky453yF6t9;Pcm0rlbUSd#O>k3>e~W;R~(Ie9@hf>Ng*%{Ky(K`G=D9-)uupG+YS!ErWcXyGbE=`*+j#5*!R;Gpj0uGej#tb z_3JSh_EZ?;@6&gP4BLoTz+C0*@_4xj0jQF64%d0@`EXZd2~u#52-kXYMQO27uRC9* zKYd{J^DTNZbtM(m5@?R~{$R=~+Wiu-Nhl?T7u>O7${GjLP=Hl)eOG}&;N}Llb@}2E zSXF-*(t3@QT)~u&VT^W+7{OY&+Rh{%H_i|#nWv1bs0r<_Ajof@mc&m}3wcuBz}SW+fwV5i$9`0g8y)8q;uO%-rMIyH1Ec z?&fe^o}IB+oN=h@30pwWQ^hhHm4jmg6%8MiHzAn&vv)_09^gb@H+X*`N2M_tEHu!g z;_O!#A!KY`t zp|c6=U3xX7^59e6l(iy&ythv7hkXLRT(3bExWv3-#-kwb_i0cD!zL8(>vVe%R|T_V zF{B+=VHTKvw-49Efu;TVgFx;t@NrvMY6G7rB@|)d0Su&r8el<%xvP-Pfokvo)((Of zN=NJr>hQD!sQ_gzlTFStFcz3Ww|$MyVFJ;1%r?lpMo1a}+f9bl`6B!f-t`!RHZprm zj5Wp_vQS?xij4hRndwp&N7<@*r`LzJzmcGZ!s*9EXyMahiJ%3B3mIly4iuuP`;K7SxR_8_s~aa-S@4H`dCk-)gZz`EQe7kd{qNvFvpm>DO6uZPb!GWDB|(m$HbHG zI|vEPb!_m6ubwmK0RhIc?w4XcPs}Dpw=r>-c<|KkMS<20accu}^|;B7eZz|cm>JIL z!HT0FtU3f4PGJxWE*>!}l^KI|x!Vm^cn|p4r5_#4iQ7XBj;Y4!tjft8yAc3a2mbSj z^72a9L6;Sa%`^o=rSPr;^$Q@s0Sr|L+}nCnGC;F22}2yF)7++d;I7>`=vYhrSBmbD zpmLxO+!6AW1j5YAC4s??+{_tH4s^wr!Ic?N1Q38@@i754eB4LR^2|re%qy-V2JRS{ z8BlWWxYZSVT0JFJ>aXhxE@~K{d4nDo1jJMzzTwsY@Mk#|)EnVXV1p|p(EVB5X2XEL zZeYHvFk4Rme4cJiH<+!4tQ#nY-8?OGq#-G=eKC=#ExVPN69(LLhx-~$vn5E?g zKSB-%b2lGDRH4movAxFV@DPVIl-F5U{CG`FH?L;U!0}(Hm-gi*p9h`-&`exEo;U+_h=0cQ~STQkq#@SoNhEYj=kU&rkDgdV%~tOa~ZZ8x4AV5+YM|$7J<`<=4Ep3RaIJL#=KKN zQZit5p>&zKoJQAT#xrv$!b;;x+V@5z}t)qcPD#ZVJE?$bi8iyu6O-=r>A-Rz!DsPs2s5KAi7J zTWW_%O^@XKe2sg(W}Vb`cDx9L#(+vWy$@U&uY?bRtm33EMxXJer5@SsN)+z)`vSSU zM`KC`RV(1*l=YlUUtjRRh!r)u9kvri+MSAKxZ+4EKjaV+0(wLju&M*;C`NgJyu45y zpi4vv)1RX`N^p~@PBKja{DztWv}Q0w7-4=8pi|-yc(aP9Vp<`vz{?It*?FCS93u)W zBSHmfGOr_4<`%&N`eAWUqKLhPuoo@b^Hi*DFpmkqwZD(T<6ICG@Q#!h5NEiuKP8+C z%X%K}CMD!{m~&JBy8SX$7GbSsRW*~pgB}LE!U%aeH2idaF08oWb({%C{MesW(PA@c zstem@%MoEW!={E!bBfV$2r!%$H_YvU#^wpL$YB|w{2n8C!RE3!!wekMG6L+Q z@lOox>;BC&y&B0HCg|Q{f+*iz9P{TX=3f=XYnrZs4&$(1(BU5DYpO&s{VP7z{K_n`zyz$rk_@le9#pm@xq8 z1=%(>ct?=x1hYB{1B{>_koJ%j3)uHSFCE+1Q8>I*V+=SUu$4OsmU`jfh4z?GGefa6 zP{8&*=5?^gI?W<`H(tC96ynFhp6w5WGYi-kjizw~OPhRLN#C>_=yeCI;u6)s4Ik$bE!c zhm`06WVrM7Vi|A){F_mC;5Q8agr1#fu$s?xLjU*v?InQ5=x2BTfSZW*W6)ojH@yc$(Y?+WSOr(e|<}C$=VQbHwev|jj=ZZshZk|Czs! zJp|&7dEl0@Mn?NlAz;YcPBH7)bqZDn)wiQPJ0`Ewhk(XSn*h~TV<93aA0UEB05XBd zN_yO@^E;{3E_gM3)F@TATq7|@-(?enWzZN093{wC1ZC_RD30X=WYiKO3>)GvHA#``a)tWJ?I#|p2uCd zHAiuH6O2ki-l50Q6w&s3i}V43JS{smnymEe9)6x;{?PY~5itH4Z^(e5%5{GZKfA`y zH*QN?zM$Dk-KwXTI~6nk|J)+%oPa}b^jh}yp`Ng-H1=1}qpDf=WhD^bFy`ML16=FB zUpRpByP}~z2EhCHd6}k5*#6_v95U^%UxC7x{s9}CR*&xdtWAxI(G3zaYGsmiG>70 z4L+TXc#KF?q2VJn5#uQz@+YKa#!t^H@#-WtBeR^Bo ziegp1LfAabBJ`f!EAu$0y7dz^_N$vcTF+<>mcuVy+ov zDl|2^x# z`Rx##z$1ggQ68S7nE~7--aw}eG=_A}^XFL+o(=EC{+PGR2(i)!J}O4m0j%(N724j7 zHFabegB%b@(BCwof*a-S=eBfiVXTcQgw;>Jcs1tG{Wy4)!85PrIXr_WG;`+-IX<;Q z4%-gt@y4?F>)AdaJje{p?J!sPY#aVS0gd4@GGW&{CfqfFmSKUzH*#lM_ih?1{sH85 zzgG=khSKpqrmw=z%O1I*Y9Nj|8;B+^mT|lwrL~RF)A}p9z_XhYU4ep@-zUiA_WkEN ztDx}iR!V87vh|eIa9h{0HzG`_+I)OKXc#eTTwAGl zs->i%W%W;Q$9#S4B2o{NNIIB3Fmx{Qm(N9O};b0>v6OHirJPdD92#X zhC{jMgv{-LLJ6t(aLBL8hxmE7s*YW%mC!0Yz4$iYdl#U#fXmIn*g9|qly0UY*PYiH z`1&=@XGaTog!|6dA-2s{(gLU5i|OqzIP|=R754Qk*qnl)7~RaQq;mC^p{+0x|?sE$Za? zRlEs9aNIALMTtxZR+o`h`?grt2W{@~HPiNQvE1Ti3-Z}buq-%lF#1EBLvS4JRD>jd*go7+^OZAjs;h$+H}%=C{4TLZFX zbosFy!xZC#HG!`c5tU*Tet{bR1Lb7#v7qpY^A`#=Q*Sq8V?3ITX(lQ*dm5l~Yb2hR zg+Y(o+6chBcZ7tenWBGZanUN)l0)biLNa)}cMefc^!zY)v#5{oJYMeJdGxhADtK0P znHkc3vIJ(V17@Db+9uOznaCHa7u_Q`W@u*g;2hF2)Kz%p4mQAa-#clzPvcM^nJ`Q; zxS)?FAMIiqloDowO=$6Wfh#B&yoYyi$M|g)lbX=uhDw0{Wy=QVH4BqJL0-|qO!qLc z<00-WhnS9?KLXLl{pPsyA%{c50fY;B!$9u4Ra+nk977pyqFuw(07T4y`%W)rMEMHA z!fGsl#i5t!=2{ClCdO-A!j5S(D${q}Ic%zCT8z$=hRUBdf`{ z)-2Vkvb0RXai0jlGl$tL1(&_;StcFEg*$7gH?Jl!{Wn3sgYQUzPmi?HL4mX;{Xu^Fq zuQ1^(rbW4^H*gs`k2;&%!28<^={8@g{XQ+29g5k81Fwq9Hec1S5tKHApdsnWRPD91 zr7?rZi&Auom(A=z<5|ViP=a{b@i4^qcnYIP8jh8A>;t2yDW1E-LN)SZ1nV)lSF&5< z*qvK9XbY3v=Jm+y))A~bVTRXNd5-2jyEP5(fysQVQIflXoW~0x0UEI|#jL7vhJqcp zRGUE^YFP=-1GYb}gk`md$cS$I+{Jvge!a5~v(8S_&9at$S0r%r-Zqtk#?2$41u>gV z!fPQe`}xr-8%spr6MOYSUQsPp9?;C3m>!inI{AP~@fy_%i9_s($;O0?^PJz_F{B5s zQg;E-dxQ92qxP(X8M#0E%i1?2YH75M0Um8<7wt{Z0yn$durpSL!9(O4C=CpRlS7JK zyk|q4`!U1Y+}|+}GOSS0)3!&)+?JU%=0iqYMYevX0T5#XMx2sE_fJ4Er`eO$=w@eO z_Rd8uPddUdb`^}ABJ$uTgb6kEL|D zkWStc7XOf-6#BR+b~$u=H327A~5X;|GEbOhWr zcNWpgp`N=)Ry1@NLr=YaPr-OY7)&KNGqwpGjh&&|xneL&@6NqLEl@*XSwmySm@hw5 zJ#5vpM%#r)K(U+WoqDBrs|L^%fwI`fWCXV)6GqI=YAlK(hUiYYb~w7Vc4LPNa5GZC z3OUD#m|6E!s|~?y)&>AdJH+F0LL_5GC*n$n3x>cvfpfEr9zp{F}z zz|F2Zqj|MC-S&V&rb^gpZ*AKiNbgZCvQ^em%4$O$6IDPtpooq``(7Zpjo2SEa(RJ> zl{VoQtMppPiz^JzvHJoogfIZI74via?ILE{f*PiZr+r1MC=1sGodNFVx$R3*D=yo* zTWi(K=y%&6W$mDT++wU2dum=R$}kn&@>qKKH_yd zI%wX|I^8eaNIaRu#G2hU8$0U()@f$CIOrQ?gC*cddkP()Fs0%}Nv#Nj#V}nUV|<3K z!YnO)K=rr=tPU=_^VW8}T2I-{9kIi1jQGq9*b8oi0fbBjK?v|*tZFwgU0BB5A6XbG zf+KKGx!`YV9R|@MgjmMiImB!+(A;eg3uPSt#ve8fQoXBra$^k0N_)&)HY*2d zfLDV0UZ(wR>BOJ#unX>;-Ii}1Ylw4UWshdH?y{YOX_8EWy~o_w1F8Xy&Sx3{13((f zf$W>B?Z!!|{jnAj?`l%P1I^kk05D26<{B0_T)T37iXhHlRT0*gl|?Xi@_@M$$k1&N zl;wJI1PqMBz6;;roXoUSSyHhizvz&`@bP@pP5{Wu1ZTKvhC5=)pYL&?rT1Cpjfme$ zks!Z7S)AQfEcU$Q*n3`hV6f|x)tr4B<)}34yIP#~U~26EFyI6qMpR8zg#!Yh*1H!9 zEXfyd^F|X`h&RHKtWDo+1H!6cr12rJSVrWvL2t2=(wZ024OQ;1MZgi9U~Z|It{W+JwIKx( zj>~rYxoh^rDd-tEd}DP^^e~rdnHz}1cGFv6htYH&gDJH+(TyP(Vb!AtJ9KqB6`EBv zAIzOK9A)xU>|wW*__W0SGPD)K*tzUxtMU&3LF;-x?O^!;f;*YK-EQ^(abNcj^Hh3K zZi@mWY$0mrO$0<9vpq|9!lZk!sXj+!l-P%fm9XIo7zSMmtY|q+FUAe1P7uq)FAegG zMZPb@ffpav)q&#}(daf2WG-zUc-crW!%6wd8Z}}*%dU4RW+fy$B!)Q<{&?9~!mPLN z^CMab1_QF#0Q0r?dW&WGm;g9iKA9*6Gaa;h*cc%Bnz9rOZ*QR6MnBe00>DK=V#@Us zTh}_@cuF`Oocmd7nmM-?iRhKZB~EUNYL(uol0rK$Zi;y?6GKB7E7tEl2x;l0cF}Boc7GKN-UB_1PDaHex2D(}axU*F37ZR*l$I|mg?kw0| ztJY`4!0Yl|XrvXkcLgjT!BpsA-J}5lYol{|a3zcZ$navU41|bSl;iT)x2f8@;Ix1p zne75Fd)DEc4cK4|EIEMO-6cs5kZe=c&TdVjjWR6>M)__x2x|W227p%__rS0*W2lPz z-Z#s2&2v9}SN9tR#o~dl_Fnocn>X3cCP&=A_B8t~z)I%=9*@&~Ynv4}d$9O`#i)u& zO)>N{2pUS-U$0_z>>@H8cKaf0F7Rj-If62uR-6IMOtG>H)kdSZD}6f766e|Dl9=fM z;Wkwvu3^?;owu3Z_jLei5?l_Zep%fwFyr~y<|;y%Cd+DNyejUi;BX>o7>AiIPc&|0 z9J2Uj4P*6XG6?y?WLk^OP#Z3&o0f3x%poqhHdk>s8vkw=rDB*5OL<7T0Iv*gUvn3j z(2jnCy&)t(g4a46yx{dSW>?1Ulu?*b9Y#RHjx>#+85SsL3;J)hsk_;m09=>@>;SrS z=Xs7@g$JGp7#jpRo3If}F&FDF7q?v-Gv!^~HL?BAZc^fw+z#8-xHsmCJ~3l(!Q=Mi zc&wZ#hKE?O15hB{vN_l8R%3qdY0{&uicBV2CRH0RwLMI;dKhSu?_Gm$5MIv-P(5}R zHIszH1TgVGD|g%>Gpyo{yDh)uF80H@HU%(kdfFo?U6wg~Q*{(OrkelPqor|Nhe7P! zo-Kh_wp<6^8pU~buXrq6Iqj6=b_Wi?9CE(@9#C={++fHJbtGeOa5S{^O7_9j%}&!r zviP;Esw%v~dzX+SHN9rUhMU zjE%ODb=TbkO%Ef7R*eTEdg!>7Gj7s0(=7}IBBR!MYn`lau_2yYcPRCeRLAEslVBdZ zzb7u1D?rnxc3stWg>@%?Z9}%JRXeI|xn;5!a&cD&3M;jFYP3Ptarg2?MJJP)V0GZk z>-x$jt$k&2n{~lfLAXhhn@!zjHSqCTzKtPA%i@uYEi(y^CZt*H40JWcz<`6;G(x{H zlc^>*BBmQRfc5!th1VSW*Off17BXmG?ci&tIGdd|8+O?jf9!N`+~HH~#MKiDL-0{;}O+l__kh$EVFpX~+=e#-E0Aol@E zGWP1G;}3apQ*D0iQ$6?&wq3?CF+dpeaU+Xp3GOG`2x7C8r|i8mu-DidY(NX$ZYn=O2$qQCS6{|C7+`x#OGx!eR!<{yna zf(lseY-`PM(07Gh>DqrU-~Ha^-tS1?TR~8)Kl<@VJRG)aWK`RMoc}(3slf)>t>ur_ zHrmYB;E&|YjFD~FZ9!uh3P3CikAEKix2sJty02g{cq?urZpW6bKjM|;Bb%a>O;Nx+ zJ1$XRkeJZ|ybSJ9r>*7AvJisTw{fdYT0eqfP+6L@c~OPVrKL1G(OeMjP1^DbC4|1_ea9dd&uTBo*4ss_Ap7p`A62Ai=KcY3h>_tQH7pl%-XwNxMZhstc8 zns-ME-sL(hq|mF_f)C$-N1N^|BoO`$bF?A}!M5JWmfAoTE8C?nNl#!5G8?C^$NPNk zEl?sBV8Gp(OW?c3kju?MUI=W8@f7rZBqmyywmA$?$dr@k#*FNnyaRH{SI$j?tT=d= zbx%e`_h3w~`SRq3 zTH|H;YUjZiZ%~kJSy*{||A&g<(Ahr5EEnqm`vBqDx~iXQklhvYZAv9(3+Up`$~>pL ze52W0@jB{G|G<8x4jQl1h6&fSHge%H+Y(Sn*UJw)xoyV+MHCRCJW_F;(+2$@^JKJs`(oCbh*`KZG zv#!$ei^8q)b=!vrNrCj0aRHKcz|*d)EO#7+51U7V*dbq}2ih&&2)TuYVnQE)dw6Zp z$^3`38%w@OeY1Mydh9AP=5sKN;u!|jD1j|Tn7C-O#>MPo!ch<`1s-jkQjTI2+RpW- zb=tTDc)daVg@vpJr%}D4mqOL=vl#8MT`NEm_5ox&?Y5SR$j3N5^dtufg|$8>Qhevb zUXE$wNSiyFw7H*j%Pdwif1ZTUfC6fe7aDU*_QeBfrt3&)2Jv~n%^t$Bn6QZv zUJsZOp4sipvx>ESx7poa!Gz5^xV<4#yd->U9>yizmhE4oD}4(0yX~>bB;#YvpK%cT zGNT;nv?}ImuQ8$c`I9m|7$91(%M=41!g_Wqi+)=+{5=cw-8{s@hX1dH?@RlOM=!Q` z!V*BlR~ADCAmOw_)mf|$s+fBw%L>5P>RSliy*o`@w$a$!X}{`;Wd(HrV=*cBVcW0~ z?D+)FaRj?N_+#*k*PYg)@^tI~+*QJ4^h@A)E#LO4R_rI7*zsLjKK8TEtQdx~RV(BC zb@T5#*l>ASYGv;Re93+R{9Dpj86-KH+da{z&i&#z?-UMvhadT+)e zo>v3LSMJsKdoL-@bF^>)sVY*K$Y}gAES_@^p;7dGXf+ z?Ht}NQ^IRC*{=prm?5O-kx-123v@M_|EQ8k%8t{OIvSu-Guhc}sKhs1r%(y%lbT+j;E>-HFfe0hS2`x&=YkKNQf z>yeAS?XCP78{i+FS=4dISomaJf&E5K8&2#-KcEiKDdwsH;!rmXrsZdaVb;^_><*ZQ zPIq+e!i1ZAWV`g&#<8z;rI28=R&Is>A_2Q5e>qS0W1{JEFooBXxjgH~h~Y7s8z;6* zMM_PS!@1deWG9|W>N2c6>u+ijPRG-b zaxquov2fVU+fvP-^Bj+CsebbC2$=7*EEc42xM_*O+Ey8M#WL*PYdh7hWXYqA8|eNr2wxn2=_*B)fBreQ%knxL@tkT!Ao(3x9uO29(jq0v*pFRMg}yy4^$cMjM%W- z*h#&jl|W3c{Tdg*;ef!Hae=Ef0m(f9_Z&>C_MHs#>bci`c(VO^stg?PW{+s|zl7~9 z=`l?W%jQD%-HF`Kp6T`;)7!0c1&|mDewAzw3bpQo&2vt*07dd<`CZ zP?DPhb^tg`P>R;or)~Oi8FSb}m9K+8+%twh>`oKbx?7!~L z&TiXaPcXZ7f_vX3_Cd%dZ?^yUy0M{PGf%p~oy47vYsYAhKzh!@3`MRC_6@Os|1!fg zSdY2VtiVp+!LBZ-f)%-jII>y=$o6=@m_g6wj)(bw(?c695fu@>J1}s58JdV8T;jw= z22*z>fHq%4_}%4t?Az0!9t{E@zbNbu$F*nB}PgS{wM^ zV=MwgW{#ogk$KdBHFJkMa@cs@;3t|~4 zDXfWwZEjg$JgbLOIaUL}m}_R)`ZyEaF~SY7-F`j}yVj&V_s*(!KQez0GT&26HL9&a z%x5aruwNL|)6;pFwcsv%u-;wx-zq?sS3VL7-F#>JBnHbo?T^Skm=kPvLD=0g*>jRT z4`R;=>t|h(ooQZF=N|4t$iM1-Ii0tAvhMqeCa1@-ynAgts>a#nnU64jY>r)j;;Eqa z1C;jr4L#s+LklFh>%EvSH|5a|<<*wc)+EIu+i>@y*uulZUgiVz`}<=ca(>0Si=VHU zUV844Uard6WER?P{Tm{3dJk@q^MNHpO9vinzNUNag0*g20keqtibM6l5G=0&^4)|N zEHgdv3N+w$r4Kz!sKe44P?*MJy6r@nFze^7?7ekVTusw2N`yc{2*Cq{Kya7AonS!* z2@LKszyO20CJ-P%a2+%d+@0V=a0m(R5Zou|0E65a^2+nB?>Xn5Z>@9hU*BGfS$lfd zuI{d``c-vxPZKV(d%a3#?nq98be-Nwzt4`z551FOBDTz>*6R>&LGJlVh4r;NmCF-C zozEe-2XZ{v9(Z;<$3IiH$n=`}pDW<(7y3>y3_T(42Y($=HkvMdJZ+MO>?aw-V3-jV z^TArHx`pJ2kNfb?d`u7Z^Dg!ez6besE2*yXSE`L-gjtfs*9;SQ^K|% zHsO`}%HrH@Ci~i{?c&ZSBnOcpNsu^YyCvy`%TALLeb2qJ_hXM<+i&fuc<3|qv3f!0UB%Hb{0EXJkVmjE=gd^_p6|^3(9={}8Nzgz zxHshQ{V|K6h;W#()rCfh|CCviCx&d=So8QGsQAa6qp$Ez(R$@>y~R4aQq%M6dZ7m0 z_s{Q|+A(=GG-K+^rpOUC`f9JuWQy!o4v)14aXQUB!dE?fO>ufZeJ`!3`*g-w`%(P; zxi7qz-Tu@cy1aFwmaZ-;E1Lb%BICcu3f)X2bJTn(FvcQ;L6uQbsEwrY>h zywO|2f<6~p12(ngvCmN7{g7NPFmpOyP8hY`%+^S`v#*}{&f?H^Q2zG@slG@!&K#y6 zwK7C^xIX*k0TGth%C?qfcz)hROE9Nnw4UhHZ?4eZWG=3!qAo*R=gTVJn&uMj7#JbM zp_LQ^WGC6MIx^+8OCF5e=_Tx5_d5rz0sJ}a-dDF*TFSu^bIy?8=_OX?6ru)~enB_{ zR>~g?#j?Iq2HDe`3sC0;alYmL3SYf1Nj{j45eMH-DE`G0ty{>`E+i3mTqN@9v^IK- z6zXd)_3JI;)$#8FecHv(FP>1n{rpZh>JAPh?yGHi=$m5;j!j-C?m+y`Wu=jJ zuFq>9>ej0(c%D_Xa@q%dX8UcBig;s4IWB1O1oLM-%kH|l>;PF=jqqhw-MqZ#j0tmD z-N(<;i^xyRuf;fKv47~OH&{i`gz!u{o%aiCc>V|@J<=g`;(jQhiU>*}s@j{sUI}!O zYX+pKB@2uYPEYyvmUs5|jp8264TiD^jS4o)_l3~X?4E;~Asf8#I}0XDkq;vT41CNX z0%p%Xq+4#cv{A8tfbaQi2+ixLcx;tHO*zDt5c2MJ#(X?n`Up#lt9`Ci%`CHg<~AB@ z5)(o$o*t}sbYFVnhX9v$Hc#jMCs(kD^{b3Rl5MMNXC@7*^r3N;O;*C^j_pME4i4V; zf4G_}J7fR+w(qWqM|TX_D#Lnn+C9>ey>gEf+Bi7&m}ozsPl7Z3NAkg$hh*rs$NFiI zYyRUrKfzH>hS`ENONyu|@#VVd(R&MUmGAX*fJZ(&cX)9Tt8Pr;+f~{t`dbr*{qa>n zkD2`)?W1YrqK7UHiJG_Hwq^}Jw##wqxbnriBjH#<+2)=4ytlg9-*a*Y&Ll4QDYWr< z-mWPOb1!DzZAVM(9?C5+nLQTKV1Gv*LJALdFxsm%d4k!$(MJf@b4eZlxxw z2tK^S+sp9A{9g|1l2pLKujzvF6)9|)bW2-O<G zoV@%B-CNr`vVZoedB(bXP;@xdYodEm#i89}Ff(}i9O+$Ms4L#U_(fOm*d;M#Hl zRu%Vsp#6>tzt;>M2o<%{pIopuX!Q8GF@2U3RlF%m*L7fG0Z@m^{tNVq- zI3fZVL^)cs4)8WmK}rUR)h+gz&$d=seE#~%ZqrP9Vi*yz*X6P{4T-1eSx%19LXcN+x!$$YxAh8^*uJ~{Cc%peuDk|Nf`xL%yZZYwM=@IV3>?8B z&$^>*h-PDCm%&QhU3~D-TaPj0JpA4*S??WtjoyyQvBW!S!RMQ=(UUxHQl*I0pSCA& z9!yp~uEEK`CZ9Pv-2K=DH{1=}H;@>UBE}vDPAoi=CbDcW@n`Sr>e4?Ue^^;O?Ow$( za$#q`rI0(v^9cIQwC|CU9bt6IBsAyTW<1*f==v3$SEbrfUti+ALpy#JII`q3cgP=w zXJ3T+o%-XGD})K_z1tx^rrA2t_ViAM3=t&x?bEq@nEh`m+(3A>^3SYOr2~=X2a1qP zvuB~WE{;kk7L$I&Tr%>nL(QkG>WK7d$T@{Rn}@!mFS=GV2Ld*Me$QvyDJ9bRO0zH-~4MF^75mT*SlbzbmdFeA>U}WnIPf? zhZy=3sP!G|Ibj1l!6x_HA>HKOi@055_tX}qb}}VX$?618wt?H5Qi1odYw{fUtAZ{) z^@n)-^4&X<6H1%|G1*5uOT?DogSMG8m@uvh}lMP z!h=k9DI%@cthz77%E#QHB;rPwI`b+rD;W98Ng)MA{37goT~|xqHM5lsU+$-zKx}F7 zI+aJ>_aBpAiavN~>JT`eyz?_<`9VRL5t79ErGCK~;S{<2P_UWfSUL|VfUKR%gFonb zeDFOT3PRacjMWp1$|Og^-ruBA!tbMg+K>oN_x2^wt8VUBJ~tQCT8p|P+E8+?ikH(m zSW``L_K1L%XT){Pj_~tu7w0;C((57@;x2gQOR~(_1J;gU*&&>|+RTE$mSsrR167ZA z(HU~wI`)y%NK;l?37q(cKkI8IfSH~imxG_lFl_|x%ypb=tfXT2i-=8PlUb5D#gX>mlPH&xs3i9)f2 zi6F}eMqh(_GA@FeLlFd42j7Te#7@NMFK>eCEBo$J88#!54f3}a4X zx2yXd(jy+>i1OH3s2_eaHLIHZ?2J_tmrbBb_>xHTqwn+W>MvdqHF`x=<6>tx(q2&d zLAO-ecjou+(><4x!v%v(o-3Bfg@+OCc8gv}M@cAfzzo1#&TJnZ5XUWJT?Z}9r3M!% z2rv`fX)>}yniFlzW2U;zT#483uH9b@xL00V-#(3DDWOo&P}hV1qXE~zpn=Z|@6+t9 zds(i%F;9C{HJFHABY4j9pZ*BIxjQjCuZI-$!vKtq9pE}TV!tP5_L*Cr6U%75^vNGv zz!M5|j#+x;gFf}m9fCUDO-C6hZ0-Q%FtuAx5Lkr_817C=IrT$a_13HM~_o=H9mELKZX<;txbUg;5NkU{_OWPpF-} zi?F8{%?)2+)IGYGlZN_+#MM@eMn_qVTH3)GOwG%|%fZDi>j`lO(1<^v7In6;6jqm! z`v(iuH!&J(S64@2PEHRG4-O9=4hLr|PHrI~Axrs(a@ltQ~$GlP)B9uf3dfB`G*ux^5FC|b>!sc;NpZr zIsf{Gi>s_Vipf73^tW%gfKZ3zajJt|9Ne7E!LsgPdso`OvUsVWtoAPs=q_17ppG}4 zLJ99bDzh;E7oDSro2MzTzp&t?7Tv} zeC(#Cf&%PZ7G^?V9zIhuQz5`#Sg1NfP+Dnf_t#dTSy`Z1adDgR^YfYVuv=Jg@v-yr zahtK5nF;c;@t6vM1t z{{099fr2$$P0?cG7U1UL7vcl(^YL*D0{FQ9O{4{Oc0s8enkzRK2hX2oTbK*Wp?I32 zR0jezwE}ZG+FRYcf*u%QRCiFKHAQPGit|l5syD*Y&R|nl2WOCjgPj-+y0z43mj8OJ zj4~(-Q&&?NQ&%vmHZB0KFc+^dfE&aO5C#Yc^K!Ft0ff2!LhoP!vGn?Xqehz#wdkKg zmxs8Z>i4=S`eRcXV5dLd{(QBA+!zxz^^I8wo0|XWf{Up;*y5(0C|-XanOmFMTY*vd z@ehUlXF23=l)=mbY|bypW6sWRW(HvAwXhUm7vd5!W#={%;^zXJnwpsd`2Ul;i-V=B zhp998g%wJUC|RKt^hQ?HO#c`|=KrMkum+M&0SxgCye7(g)M*CPN7>sLgCAd|h-`VDJ+@v~ykq7fqjwJKGD1Xq?oL)M z$G(DT>T0$xAjY(Hbz!VLw6tc|X1lEuB)3q_ySXNn5|lA2z5N%{uKQJ0{Py&(W|jlk zTi~w{{yzg!$>En-ew)|$^N2DJpS_p)UC5gDfZeZOkk4F`3odp?Jp=af+7Ih~`61d5 z5x!nFEvo*T(cf|4BG=zKXEc`Qe7A8ae)%o_5Qz*-@N!=KPK^*(lAVp4P39S=7oBvrk_j1qi37g~MO zVr*h`6;ha}kJoBwAyT6bU;oehzmQ=3<^I2tqhI`+YX|3ML^uSm5A+Mf5&3Bq;`s9( z(LS?ZQR2T?mp~mmO?C7EOF0Tb8n91V=85OkBhAo_oa`1K4@dkCmGE_L!3#M3TILz; zfAo>D+h+keKN0THOP>sk^0+*nXjl?ETPk6Ib2_yC3MYK(gwc!#Mr-i@FM~n)XD}SE zRvS>drYvCWN7Dj7-CySCo1dz&((k_Pjb~)+7I9evvd*uqt*v+6S#&x09_`Mm-f z*9H<91(z_~srneu4gMqg|03f5Iy!$y{ey;ryy$nxIG;_kZ#$Rq zT-aakhT62$SPj)jA>$cURiZrB24Gq(gM)*;`}OtpkNjHtRod(huAB#9tg25>mUktl z$7MCLkhD!_Z^jWQi#Z!;<^vu_3kQ zcfzvoyX7?BWk5Kw!`?oL0VQKI_3uC0uwJsEW!I64Jwp^t)<@1>vuFWWI!>b3Yb7W? zb1;^#d;F>{Kjxf_4Q<1VF}-8es}}fG)BS9kZUNof`p-4Ua}i&l+F?mFXfvrab0T8} zw56Aw`<>kXa9FKIPFS?`T`QUD#-5s=v-(_J@eW1d_UcdNO~fz&Z6>H(%+@Yxc?yA)OUub%~QgOPNPrci0mZ+Dr za|@5v_u3_>y}e3QLtUNQ#PwF2n37wO?UpP}br6fku} zAeU?~Vs902X{;KJNJl(|UwciXHlbf{DO3D1lt3m*eDbvUWZXD{SWuhKw?l(!$DA+&p*ifSCYTp{}pZjuDhr)@c6%BDbSPE^#Jge%ldljmP(mO`%!#+yK&=TMP1th za*9(m3c-BYsMYdv(iR2OG2#uxaGzb}_~pxN@iJmKnfvaFr^64%`lZX3%Zc9ot5$z2 z*7>wG0e>5tmV!Z!7Gtlp8xXgB{XjR$kNp5GoY$@KOjPFaH`u_XoNIC|os1rM0OpO( zU4`zoUE&)0qe^TsmWxgVEdC|P*M75)J#urN*aoBBK*wuIdXn}?&~vn!tMQf_;+Br= zm4dLB3s3MKDq>+^=)}oHdZ$|{Y$?RkQr^5mt+xF0(a(dt@EszwA~_byvas9rxb-9` z@Q4rx0&h5lO63nz>fp7a)4qRqseP8Y^V)DR@Q}0JZOg@>>1>PemtS`@RhDS`#?Dkt z+49v&Z+!f6hLB4>v4e|?i*pNVUz#)(ygHsUt)<<-Wv!1e^wKlU@9fMNc0PONRneqT zlHIbWt|TMFp0%3n-L5G^FjCCz#$sk>*0~$t{l%>ejyOJf({)wd^Zn4SwU8LjA|mE> z-7KX_dG1*;Gk<Nzw&+2T;Q@N*O;m-qdWbe(X6VqW8*ikPwkZUz<=*;#DOocYmP z1YZ0o0!aZ}(`vn9f|42#IQIKD8KCTdjJm~*K~4_cUeS82Ef%W?EGd_$^S*e`>JN%# zzKIs@bt*o99gvEs)Ea5syHQkZI+lGI=KZS^%zoX>j6S$@$s@x1X(*wYwCEIB&kt%_ z6!gukUiV*#Zf{I}Y{o-tv|tMW{29LZ(zl2J0J?D!?@7xR8#LQ{WpBj)!=5*Y4YUDV zeeDYRgAw?rs|4f#S=B#?b%%ynJ|Upp3lX392ZwS&n$CG=(X1AIu|KUm4vw0?VtaL9`X@# z-+iTj=sG;@^v{rb8hg*>C8hKX$nXQ{_!42O{XY^kRx?)I3f5TSihA9he2~a;Tfg>- z8a&{kt;%|>^kJ@og2f#QPN}w zy19q1TK*AIGE<_bmSRh3LV|hGO(6K%NbwEJYVS94b^0%YEH{jDPQQR~rL^G=6%>yj zk^V6-ol>AoT~h}0oL?v<0Bwdrw>7W7lL!4Md&P0lrA8!&j$8KYEc-K}A z-s7_al?;Glaet^}tG}wU9KSOTOkljkL0R@|znQi=s^*oe6l>9AHWts1;QC@tWGrM>Pcg4<}MtRz{=6?t3=#?d4Qz*PdW-G8gpDq!7waAE=*)(kIKCiO<^!HG(a z>!LX2Lg7^0%LTn@fAENUu?!u)Q&{b4amg=!{4vX<@V$28h+!Sp;riq0w|^RR1w$TKkh|)p(+yI@@!QKlc=NDUqEEkYVa9^Maa;_HzDX;JRs6LKl z2h<6F{P>~)HW8!CZ8Lc<*rw4zLS)+B=F(nb1RzZx=LKW=nmXQHN>ceeVz(X3ga?g3 zNKsjn$m%7i!E^#siGM0t$-#+QzD--zB$C3+Ki6E%+e@U^>H-YOEJ`h)(KTBdj!Ne1 zW7uKg-+PYbXNI2RI6k&0wz`+j+B{hMU5l@?Sjc*=mL2uOLL0g^wYsJ^D|~4>GNNTuThM9Qi%+z z3`FZF<@yS-1Q^5xB%PJ+oNxQLV$MGUE@1lXy$fK((#-#R%fxWM8&7Sb`sn~4-r7C7 z-nJthedg=Az|($gxWLCZ?{GP_d?nZdZ-!roWMz=UDYJaLD&8W*R<<*Lj}`5UpTHWZ zP}u|ji_?`}ZmXe8C?$eXH8cGwd;rE%=9!k37QYOILh(7@7wmQhvNMP4lk`{XaBuJC z+s-U>OIKXDyM(RQtPK0+XDP{~YyTd(2+W#?s~VmalzAfjrW%y5TC$=#n^~gQv5u|C z*WiQX@SmV>VLhao*LzwmA1C~y80nQHnRg7oD5yHrh70;pZ z2)+IC>XG(J5ML%J!Tvf#Av>S8u`jDfac{%gcHNOs@~OJ`P0lqrFyzEZ%>tN zHcfVo@t&n4_HBS_QVH{6?pZ2{d;+JA7Ir)lS@Dxq7oEpsXkTcp7&5L@38K+-JJYQj zHw5W~2M4pl6lJP&nujozzQ2E!=T$vBB&a$)=Vuzy8xSB3ACm<@EsD_&S@69~)45F9 z#sRBLUvg3I%fey3{A#lu5G=3y-Rp1dZ(~yQ z+pnkfnwrklO8}bX8^aL~)L1m zV}#HtqQw}+gmxy!w$m!Uw|#Z~-d$?+G%!XDSaL?VTNbWYoW5F0h}pS$2GDFde<^}7 zI+5kiTM?S`t5(NSJ!6utw$a&JPiA;I6&VJC20(liD$7#Ct4j4Nwb3|64cyHYv=qTi zX!&Bao=!1GxFOEKge_U6(uKaTK2g{~^SDLluo*3t#?VpC#-ZKY$>;j$oQ`DF#2BLj z6KDxnra`X3`29dUbHSjls~=}O@5u14`On_U@+;ebH{i8?k@IvzsJvlSs39g>88<1|}>`D)_d&#k#FXFD6AlsJN01 zq@Uj{k{UaI*mk7j0X{r9Cc&q(cz{-hjc)kX$jNDuO-$3hJ0m{h_3@8j>Lme;Z@AnP z#sS9l=^zwOqn z;|7i8%PA}4YgD2UPyG5|29*dq9n@Yxd2pld_D()T#IPaYTG2`aVLVW_?e~R8!;;_SNqe2Mma*Q&0MKGh z#!@9>fu@L1AwzL1oY*0~M`Z6XPOF7+?m)4`>S79_w3 z;cYwcFkxvhN{~r)yGDOM)65~`!tWwVypb5*dGft?-zaBcKHMX6?x?G1pJN0k^VvMY z61ljX-{n&*eqi{^@A~t+M{?1=KZxoQFI2M-m2AMMj7n~b#f&?Au-RGtdDSnKlg@6~ zFtqq6UZ#bLP(j(nsrnOeQ!*pSnJg^?NKCWZpTG$kb~;|d8PkE?Mu&SJYN9`|Y!r<@ zE;$Iuce^a=8j8u%jm>jz1Qs!BZ1rj~Ybd-lEz!$Gp@dm;R$^ZtQY_Y43|{ey76*0{ z;3oxRlCkWUeDt|JcKXvaKuNSwF_4P=c9BQ(c55SDaz5LBwYox0M8$KB>DHr%f9BY1 zS&rPTIcXIM3=yta(~=&>DR~F7ihlFeG9xX!v4-_K(*gNYnK1Q0e4cCJC(=y+C z#_t=oJ9rMUGJOI`!bg8Rl=(+541uzYO!6EWZn(^emQ~71r5xQqG~T&9OY3Bu)BOkU zNm~zc-ba-9Umv(YMk@goav*M;A1x1d45bq3-5QJ-=9Y7TXID336suuUP3n5|f&6ia zvzXEbIY zbJ*Uh8>IVc*SGxAnZGUq?}lruxd~m<$$d?3|Gq>#VE8`BvdmlS>cim^x79=W7b+I0 zK=5xb6Yg<$@h(Kb^4Jh6(<*UFmE6wX0;jlYa7a^)L`+;Cs_NG~hkH*nt8nZgJ30NU z>gH6_1-XUh%NpjV!#x_B=b+9l?bpb5hfWcA%ONTwevsV$)G*l%hTKIZY*ATdpA$RQ z`Bu0eymwz5IW<(j+`*)`)-TJ^Zxd~4sX=|y!@x*cX44O2ILD0q`r$N4x9ln59%CT&jQ z{<4Fi$Hhd6VWKQs{9J9Ew;(tpzl1z}uRiiK(}kIdJR91Rj*yRZ2{H$;X{sWdKQ-=_ zwuTaijsAe@C~X|v!O)or(VTIv>tDLteCkK5j3h_T+ij;mb;+(tlB-GYKY< z6f>fYxj*;XWJ4unACxr&-MYb!ju(>bIt3LUKdsa3RvllqntYAIqP|hro#?LdpBpq9 zf2(My*(sBb-fAq>`P#O>*_KNHyxs5|y-IcTI#f9mYhOF-RDRpVZ+F5Ul}`*nHU!Ls zdsO($**drA+c)MB!!HhpvYx`%(j4qNeKw@2goWl`N}T`vcluv%pQCXl4mHPXzdF}y ziQsJWbZ()r|75zFmF)RVpKgA{|KjBUC3kOBxW!B5HIK(IDjp#Ztaz7hneUW5jhFKK zJcNyYmd-vb&K$&N7i;=A5$D&u0%7sbIPn@Emm_~Y5S!fRoy@G-MTqQOs=gDOkmDUy zRd{ynJ_;7gMrAcS{F@Kz7PCrw8~9TiUb&4SZKCXY%q+C(e1^#IoYGx9+fHu^t4XW# ztZ(k1OHon^*rWa-vTq8?^lpov8Am(=g;YoCSVUXU%1~-X*|K)}z-}DSLI~qFZwj zQ%EU4N0w&Dr-dBMtMVa-& zb$a6>$+YgFx!Z=M!9LZV8p!=-J5;9~y@zC12b|Z{eChC{0{}HMZh4>lmUrP*Mir~zA3J;;Mx9*&oolSr0U~3!U`HgnIdiiXXpie5Js2925 zl}`+B_D3?;`+ZxPeHH8S5?C)FQ*Xtvt{&@U22jmC?*-8j#x|x35}zG>tg!EF?o&~{ zYSG>(GK?&U8`9Y+gRjVX{^Dq9Pj03$I-}b56p6K2)^o1;4%od zF&fQ20QV{QFZd@h$HpdhyIuQc%6?0^;@6~se$gMT~jz%ril9|_BieTi~Q+60jNw$w}VF(a& z>Ber}chDzA$Fk(I9CiVrK8C*FX3DEpPQQ^ZF~>Xr`10D}{r*Ab#|Zx@aai>u7|Sy( zw1u9syDmH_2GJ=+yjfd)FV4y1_PAO-+eAh~vYB3kf9aAK&&b*?;W*&Za5;AgK<|2n z&gc9Xlj~+8l{o2E8mxQv&L}(qXK8nW8)R-_qsb|<1}?U_Z|cnwmqE_+x}`=`idmH; zmPxBk?nb=DOALl%fJIkC0Z|7o)#BU8#^MJX@;@vszhbLAAs5Qvr znVT-qla?pZMF?6qkIZ<>2_yAcm6r9g8sJops!k#>81+9oBf?I?vpJ>5*&!O>@SBmq z*md`)3})lefa%qaC*b&3Ag!LU-(@Z38^ac^CTNss9uhV?ciN)bz4HA0+Qq`=&lUyu znOqWk1eVniWeRtHGw72B?Ns)6jwVbTTYkDS)sDUe`*a|);Y~Wf$1(X;?ml8hjnPee z(LbJv^6<50KPdOMml;jiHazEWq5XvI{cJ+zRq?9`%lw$4<4_I>jMsBCfL;Ih*eUhR z$0zY1T#nA_K906qF!czw{o&`5=Jjr+6cyUv$>)M80iCg^lHS7^%=9^(1`4ni%Mopwv0<`lnzNl^>d%aN#M;D4?=%8D-G z!z(*k`zh&YlHTdqpr%3g7wto}OJWBS*D-VMqbv2a3=M-a_Dah3O5vDsB43jE9A{;< z8*bJK0_ItdMhiV7v2+m<#)5!(mHCDKImn?cklx7a?Pw95$`)0HVpCDih^i z_(?$(c-wk(<7{7J1QSQYL=RisTWs6U-!RGx^{XAcE(1KE%tH8lZ~nbo*zYZc%JjaT z`{w=aYx6?Z_pJ9ipTL|Yc?}jem9?i^3#!2UIH`Pf)xrzZ;dfXL?mweNbQEu+6+}m} z*envNnO10@Gg0@TCaUVap*xmwK5x&HGeDwXS$!RZx%_L^$HV1f?TYZFS7=))RS_Ss z^&2bI#wJ%+b64K<_RBOfoxKCIfl4sOrSQwJ3?3jye~DF!>UiJ7Fv0CC+1k?|33hVJ zmEWxgCUP3P9mBND^H_>lz=sx-7YuZiFlY-En9!pvN)A` zer$E5`R2kITe^hIBOqh2p+??arMsO3-LS{l8paXZR_ev}tgjU4dYsGRftYbs6ac=_ z)%EMQ4uuI!1+s>fONeUzo)oskGLXnkqV?gCMLOuhNn&uX-A&MG=Gi+CDF3_(NGonW zeX$SjD+(JKvrB#zjZ>{>J$@C0UUjv#WLR~*s-EFwrn6z7nW2f>-Jcof^BT;y9|_qY zzPBbLqZxs8DRIj*VTarDWnVu+JLXm*lK#A6alJ1qU%m?tq z16_n1ZGXp}=!qgri~E4YA**J~g)QBmUVMy*pg_mCmC5|WKgriME)Es9@_>0-9(VF- z;$ZSQKAf7(PzPzAi-Q2tB2j!Ng^Z~PTwujFMXaunO{wx5gf5MqO!gCSer4O9_K;3mUdUsZ!KF-W$u&VERfN3-!Fm_;-elDwD*y z%+{#5_?Dx3-Z~<2`TBPoI@pX~=WRjFV{8Y#yjEzbQ27ijiPO(oEgA(X%26KYN1Oi+ zM&G>@UD^e=M9}V!vJw;f@aca+9_DWOqj(m=STFq5*^lLa{Q0~;%AaesBqR6jMqidcJNc4J39s85SlY%W z1=D55XWDflcXzsavk=|GIQsinb0;Ec@psBD+xotggoWj*&<)C{7aYurNR$)9C&Z6G zGtz(8ZCO^ zS&z1=(sp1ZBqMpU2e(nTZs&c8L%}?NwTR{A0-f)pz@tOBCJi_BggwfD zZ$Jwys%~}WXQO#XoUn}aj53ZoGC(fv^z3qvGlQDtY8glyJ>j0dv7AJ$>_>+mcF?Iv zA*I;^O1eI}uXh@BvxxwypJV4OEe6ZnYxi}sAZE8aL!XY;YRAT5 zHj#H@YYUOEFl#BO43HK(N;a*Lb!Kw3ha^NM+^p1|NHk~gaS?NuuxZ_%z{*43u4|Sz7eH1C>vSP))15sXPiFj%r!lH8W^hQs4 zF6_p*=*b@6hTt(xN8=gajS(Nztm(24=Ir}z6 zKeIGlcyFueQh%^0Ky~D`U#QCCXOyQ4YP5pYg;ryqJlr_>szHMggrRw8)1Ed3No8TB zplZH>fuiDbia2KcSlEc1fDW6>GEM@nFC*mV*tlkQu}hMfRfwWbd$g#2p3#IcyN+SA z5|hSF1sG3gEhu40)`dAQ%IUt2nHSf_{_3gGQaQXgzgZ~=vDk^1=v8S&Ou$~T(A&s- z?k{HpYUt#8^d^=MB;bMzo7(bw-hVUtm8RtSP!kpzZdq&)kayHoPx0IhZL2$xvkxua z0)uwC0Tz97J!2`PtfemoQ~6@(3Im8PG9G~o*)~pCn_AcsGT%V_iy{VMA}sXH_|neb z<|$o~OXYo4Cnqen7Q({GQ^b190uY=#TQ2I;g}EgaZzCz=8}Fb4Pk4Ra z#3GKO)MGZAC%bzT10OoA&iEMch=Ro^u3awSFPa(d-}sYt8om>Ms8XykcWdgVrHC({ zhD2Ol^L&mhuNZ9W8Eak{%Yx~6KC3&ZuzIb#K1E)^Vm5Z0AnDCgl3s-7sR%izEd!47 zIZn(YzoAG3sq2}-S)=enX}*wRou@6oymdH{c{mZbU3_ZTHsNtO39myWFSN{(kM#w?pbGhM7Brg%bg&XS zm)?MS+49yc1Zq|rFokg6;~X#ahm;XKfPXrVMkV)-DN*xXJx%s6eD@;S7p}`s_V+is z?e$zCPa<06f2WjDOz&qRDx z-^Og$-8jUS1HIM0`?QQjoSn`n z8k&Y1AFFfB59T z5E;vEdtj}j=q-$=8+P&RarhhO#>1jnrx9@eyQ~Jc^OXuM@n0$0{5*gU1pp1A)dr*Q zR!mjtlndLwd*u<*r?>q%Q8zPpXG!V7rdr9juT4u{G~iCbBK3UW_Kqg3Q88kIZ0kTt zbQ5BcP-^tU{NhQ7$s5J0?+c!2$ ziEb`VZ)vX7-dS2O;W6L62FQS9d@bd~15Ym^Yr8LUcBX<_4`9O16jLEO7z~Tt%&;;sokzc3R=G9rKe8hN5XvbE)8n* zy4310Ms=-=U0fYF#oMfbytz7E%TIv&{-QAFr{j*VgNsw?2}Qb7L4KF)pSSvLZgtpT zDkl4Wg3#&baaUEps&H7PhB}zIk4X?my)0^)FP+ld!0C@gZIc8Xj(%5f%oR%NJH}Pa z()CHwV-Cpv;2AW~3}Ew0&XUXP<4rD*QH}$466@xPH!?M|u@)6up08$A45%m42#$7Y zCUML6J&YSEE>Wduulvq_oDQduT8$hURvZoASJ%zRAnbl9D7YxKYDvlHQV~(%X^vLQp%- zzRP(bAU?CNwB?w0_B8h277-BRR)Z+_hb`-i$eH$PpS&}2=$Cm=q`v7Fz){wGVSq}k zwLa7oN-FkU*R#x7y47C_id%KggJtDC=#uoRIcdt}oEmqBmL;h{*kAP!J-wG*4QknJ z{6(C`Yg3SNeDsE~&W>3fvoc0z>K)A9yjnM2mi2zM+H^wcfxC36x6u&PlhoAc&fF(? zoEoTKpi^znKX_qJ_&Q!_VW!4INo|Oc z6GQ$|+}?8{)cMD?Y{anShKQl`#A=;AEZXmNZqPy+jYKa)f0%$}pBDfOm|UHRDP|$e zbCc^+C`n=NxbzC&S#_uRB+9Y`+afC8Y}J(tNUsvG`eTt5<*=4!-k;zE>5|*EefZ+_kzx>j zunkKrAQv_2)AbA1Q4lW~VuRD5tV!2@YJhHr$=_$H$crYfNMUWzv!v-U(!J5y(wJG} z@Ek5@**E6a&=-gQ)AR71Cozmef;AZU`4>SkE+l_HC?4oWyi{sjIBfQ<$<`g0MhkQN2bUa5vGYy9Bu|(iToj@p#ygO%EunOv>ul04@6v0&SvkIIFWbtuuhaX2TYSc9rJ~5b3UeA zUI9W}x!ahOlCrv7(1&X5fWU*;)YY1cHH9;C)V{cp>E@bmbZ(cBzHtm62_E7i2~BX; z`CG+Wc2#cJQVU)vvou(2B=NFsUzqr*#OD&i*nzE@V4Qooabt_;NqRBA00C6;=c++76bv&IG>0II<`~qXgB23o`A~u{ zw$?LEC1Q8UZgN|hB5pN8QyP`dA1EHNy#KzE?j8U$^i^SXq~+M$@7Wzhq&AjevKmX|qZBs;=1w}fDQba-%6zPO6y(aV~ReJADkRn}5=nz3#LJhqp(mRNBBB1mh z0qF$3c<=jL>%QN5Z~jQuOpNK zdTr}6C1988AcyzOLJoYvo%aPa5twuj@&7VS{3`q>`(}d*IutYiOnp0(+nT?n`_RG_ z1}l7)EShwG=@cFi8G7AQ%WQqUoV_-V&P9 zREw5FW=w&Ou+RSC@m zdc-Tf?ai3Xw-~>xs>P>qr+gvUfNdr0Jhr_Xxqow=1GHbj_8KiY5Vp#1oL<+p{@tlm zyZLPzo7P>kzqwXX^5b}U(YGD*Qv1UWEa~)gJ>+BH;%2BeG4~2^%^6q00JEliH_2}a ziQ6-M09$2AtlT9wXa?BcyRKxw)LtnecseM-_DtYq(%lk)A-M!AmNx>B#-;Nm+#c)Z zo5$AIH810dlDo1%YhiuzTj8heB|+EdHeZj!b3X^JhdAi|;kgU2H(f`9#Dm*OGNm-6ZL)QXZ&2h0ktt!{zdW`ow>B^Sr3)Myi{yc6;1dF@w^ z#@IWM-)P#J(8qfr((Jzh4Y#2ItCCC=ALi_Wryn(t7+7dYzjFCtAO~;Rb{m~A&clUo z2Kz*vrd_}zW9{d!=|f(~r-zfqxNC1Qnm@?bb|LaWToe{tM*^x!l3T9WpeK`RN;%Qi z%h6!1IKGKM(#Ue^GPr4cVKKFAygs(-Y`P?gf`U#4&5}Y7t?j?)TUhB<&OMWF7(6tTm5*fM z1&yc`1;wwE&^w@sEQl?XGt;9Zp#t3DT)<)r}z;ZVU1 zj?$!ZI5`(s8;o8283en-C!r&$j`bqrdA@Hq(g_t41rjhSDwSZ>sfWoms={G!#y|qS0K_bDX!3 zs!pq!Fzr(Kn!Js?LVOnsb*V_q*XGJ@tMQuR2;xnanohC?U#U`=^2rYC7COX5!Z!$;hPyH#Br z>g^VzuRh_$l7bQLetzE~ZOi0h0H`$EIAeOCMdL)E1gDNh`6Qd0d;{Qt+o*eodvGK4 zE*aQC5rsf9|e2i+SP>aBG?pAUa39|0 zg&)u{IM_CXtr-k%FXbD1kwK0fvx(9N+(a)7ZH*P2L+?ywoMsiVF54{-y(4sZDymUD zJfwPVlC!Rq%5Ww**~wfL_0?>Q&$x;TMnH?3vAYpXHZ}c8*LblbE}fZ?p)>`BCZce= zX}n{)BI&l(lY{u%2NP1>-SGXdz28Z6UV>_`Yl~4CM;R&6*-ASd^mD$JOEz;w)0s)% zeOVW&fMP5iS+3K8>Tg!2=`f}BYZEQbJ3sA@(q7lS!d8fgKb)jJyM0=ULnh>&xP3q5tSHbDCc~QYk_6EoXUzu!+@nl1V3q5;XzSVj-=ch%*!!Adb@rEIu}y^ z#f%$W71GJcghu)La)+Yo@KUMGQOB|IL!#*l91 z!p+{vee4*ONzht3((j=4V!T-Om=uB%p?`@id|bF20{cMuvu^4G+Sj5<|99yf2!}B> ziP>(oX1!J?4X>_o!k)uO8&gVtjkAGaVJ!cn@0(sr1lFqDv>sECARV*n!b{(>8m&Bi za4a(o=L@fgm|o)dZZd)m3#UDBozgbSAWkiHk5FYbx!5?cg&*f_!5wk)MxiS@PHO02 zs}#-8Kuakkbt(Y30+xKsQA9b&+cMqNs(wgl`C=V$2fX7q;vBztXO-VBKG*(^Y6EV4 z<0BLLs8+bWvcvv!`Se0ak)mMtV1=zWJQ-Ff_Caep8_=iKTu2K94}#{?V8|LK(HDA_ zN&KJ>@}(@bL){lkW@X(Sf4aU1rVZEK2-8tkF>*|cz|>lcN{b-R4=BnPDLLY7IOpR0MCyIUif4`@A|6zf+(0Br886SwPfggNI6Xq0aA zK8yc2NlTjLGTT&%Ov0vQVIvrr*dN(v~lehmR$Sq$W*P93#G@NA;m?sCj zwUp>^@BQAOrUB>Vb)f48wv$K?2?iM$%36xG431=eKD1B zUorAYQ0%@ftM^vE^cE7I4u#ut{?w%yz z!ubBgwzQ2qDpF=DnR8G4mvwEDfS|kabl{iZ-;<$-YWVcy?|u1Ry}G^qV|;z(qH?pZ zZO`LP#bPfHqDCQz;cgAsLW`W(TM$7<$N1?2wUvsMgC2gm_{?cp>n2wj#Q4 zq{*W{j8Ap=qv`2W#h)v+{MZP${!Yx{WRF6eS<|)voZeYI{J7n8>YTJ&t#FM|aJ~=8 z6;pz$D!E-h(kP6437V(n1Mgc|Cg|bmTSVHQ{p91gRaPpL_Z8$*Od=e?$x*B@DBp4ED#tQL4-hq?0Ywq!us>tUbCqc^2!$^X z7O5w+^fu77*K|Gum7Sw;>kD_wJoHB=ogEk2dcM3K;`;4QmkJ6+2P!_N=+yLf zKp)b}rqo9Ma@V>5kUv;hS`Kae3HNH$GK&QH7{EnqLHzlE8l6gg!(OT~%G3|vu>LZy zmoE)K#gP{GMx43KKv*Y<<-l+7jXAx^S`JxjCc1L%thyDE+{>kpccugcf?5cGc3>HP zy8T0P;)19-PB}93AOX-`SzWRIdHnknZ)|EB1>2s&7j~UxFXDS`jehe%-#3k?9i+ac zvFkvp|Ky@Q&j2k+T3Pi_2MGgChEH4WuoPcChg_#g^VjRatH})2 zbZ;v^$Io)IRWJH(RczeNOc*Pe`-(5Y{-y2@yLd%zu4)Vwce2I0r*UZ=_=iqsi%$Qe zuNNd>sJ_<#xCD=VkyK8sa=7qIQld?pqc9iMq6^_cWVk*4Xi-=E`{;P*tHB~A3lj;; z){ra$yYb9V^sj%*_kP1%#|Edp8Z*`vSc`^Oc|A4A+z9oo#9|sV9_6=st)7XQE%V@( zu=#*m9lP9IcyK@_XG)K*_0}P2YyoM^1##Q_`_=!*s&o{!G(9J)7T0pxH*c}`%&w);gzlqWp>~4 zsu&Q_sBMgop~;>)QV7!C**EjVYr6#K2>$EzU&u! zdlB;qr;+Ex*LI+${*trt_*mq6HS@c~i)@-je`gza-Vs}KXATzh;vE#XzH5^q{Wm#h zB$`V-{9yl(c**vB`<7R8{H$t+t1gr>$z#dKBrqiN#ifqiYE1vNJ49^>+PZvq1i6-iu zWX9Nd)&JpNdx(=&_%~ob#B@1Y{Pfq&G2P#FP}kCVvgB}BBzMf$w!vrh~ znOv5`4l1!_97xGF%)$M$M3lJTV#s-S;+3)Q(wM|m;)nLH>_R8!%Q*TwG%^;*og$=M`Tg{;MTk&f?V++BV79=t1DgyPWz!z~z-L{BI z4?SQy_&j=+81w_K9EB2)*2sKlZAbSWGEpt=^WLaa>mj0l!|bFXOPl#!wDUWz#px&} zn)2}t2%&vazdo!+*9MRZtDL<&rk(!ni!c#am|495AkJ96i5{}Dg7LT>0%#aZ_bG~K z924_m!x?4rahL?_&Yr}w9;j2`7d@V7^!NykBOJ(BM;kSpJVaFjI z?PWk$0)koofz=R#ufF-(d|%kS(sN@OJuIiUxGdw7U{-OZYK*}84H{W#LmSuV+#p^( zdnak_5G9{*Qgci=fOM79nDq{fKtDm#x?{O7H@+l(NV}<@K3>$_ujs@3fqpNtQ-qWk zc5LjmV2*Ya&m`?CNi}`GeLpA>#LlXYCrkdAkWqKAeg!UgLV!55Jvp|a4-4;_eJXcp zt$sU>rqbQKg}bI2ArMJsZY={oX}_;DrH>H3qt{EkR~UB(6Q+4i{$xk^0sRH9#o7ba z6}pd=0%X;wgqdj{`xSOZJl&!4M{Kq%(Y<4xI>c};y>Hqag#GG%3-5Ibx22dd4!?hS?%p^GC&UNxjQ$e4tm%!*&th@7-YeYTZ&11XnTjRK zj2ZgQvfO<@T3sRof%f9~^5r5(Sr6F5iq;$9QoRX^&Hi}dllsZtK1M2`=^`oeCQaGK z&G)VozkHF;?c}OEs}{Zepv+vlyUL0jUy(HMI^&%oIn`HVQdB{~Yf9hJVcqxA<+fOE z&>g~&Rs%%m$)7dem2g7;{;6yOiOL*+%p?mJiV!kMux|KPXL>=P@1}wr6tNcJr}T ztg}wV199>1K$deb(}VA8dq?CU6kDdNG)eS+;yiO1A{GB_KrAP{h=*b`$D&tXO6IJ~ zOAJAqvxZ~Q>T>Hnsh_HHe0wB}k}6w0FUogu^l7!%e$nkX3^&cr%KxJ9P31PYF9_DR zsY;)V@k6?)PMa@6*2X6G4>NSzmav_7Q#jsYzb)`NOB|m9Lu4)q3^h4!JL!P)T@y1mmN=oy zvGn=WHLLO!-&iK*UvX2FnH4zvYhT|`F3lLavG}pekYunAtEpZzX-KPm-${V)$#$T2 zMI*FyZHTN$-Kr~^aR8KH!}4Yw@TO5dAy-GlTYXgsb=_RyOLL9kP}^WpDlW(b6`gp= zjl|=$9{vpkLMQsNn1!H1aAb+4!0j8S9-UlMp(XD5Kf8s4gM%w3u2ASzHmt+>qSfs3 z;y2Q)&2?vX(ii2svaVNlRD){Jw>-Z1c~pCQ_Up`o7HuiFiq;^+`<>1<%h*y!j*S6{_vh&I2U3;&1*wN||YR$!2RwufP-xoj*Y0o{n)2 zCni1LPn4%ky-t~4CQj)mAttq_b>1w3Pju#M-_~uM3FSVAKguQ0uh101bnmlaPCN{) z%2|k?xKBy$7`WEFJZgYWS7>BT(V@RJj1JMCx0bmF2^dSGSuCcqAB+>FY0}k7{d`JU z(wi89KcN+bbP;P^prAGyl)X0sGuJFGT&NdY3!G?aqB}Bi6(`sY(x&^Q-XUctM# zNq8C`oYOsr(LksXHaq$xN)`vy&sCN=dc4z(p8%OS2K+>Sd_NvA1d)WrDXadb*9Kdy zJ?XblKBav=bHub)uPWbquE6bW7qzF7;25c%S;ORbiCF5&%M|+hloCEHMv)sMjDQa% z9_Wx8v-=Ycm;%8&U?bLdHMjQh1n$qHG#C{tls2usSeUyBAF z6q4CT1BeSR`_fSHolff~UDv?+P#~KC6>k=DH*|~963>AJROxou(5nO`^!gby&MaFr zqN0?(dYGC)WeGpT->O{cZp}S0o8wDXd-x!8?1IlJO2C*W|9fzzeOqdbaJmZBqy;D* z!Ig+e;9W$_y+wb)O14GP%G}oslj9I?06TZ4O)fNk#pVp+d&`y%Ca_fv4cd7`LbEk7 z>)$9+;LF`7IO? z_l+I#3TwQ-V@9swDnVBrkKVk`os%}{8?WYmeElSx_XQV*)Nrs0n!vAazyd`J8*SWl z{kOP%>oIkhU8FD9TUJxlRe8KLZjyT(boNr@(#pOfp%pf<7uAw=zgjhd`SokOpz+vj zCYqH=_Mm5Yo74bu_2qok@h1tAF4GgqVl8-=^Ur8Fr)^p1xfobM-}w`)J18%HTGA6b zs;WY28%~3S?QBA5IOD5PRj*GPRV%U|7%n-%D+qS~E~|eoNMXSS(BAwvVq) zj9JnsR-eS>&u_h+%p=c3lC$i%v6I^@CG0COHop+S<9-4{qy#+IxqK>CM1CF8I4#D2 zedc9+hsp1|qsYv?Snl2yN{iU9X=`ld^uW%!7V+Xp0i8Kfq?^$`elzoFB+LPl*qm3* zko))5$x@MxUrCUuqcc=Xo&FUc43utTIm#vyt!F8zvNZs zHhUq;S?rpQ0v}$srVX7Tk9aSnXfZRu!vNq@a%4wM+L#C5S^g5q4fe_hbv0x1mvyoZ z>kqW4k)WL8y_OWBoKsh8&`I)3uFB1@Gd;M*smWb=bo!oNZ_wl#{SoFm|G{MHZ#C72 z9@_J?OzM@lDQSQ4>&(}Wj&C+{Ex2sD{RXRwTPtXu+LPNJ!Pj;^JWJCUlU&9{GXQ<- zEPV}NoIh&r(vvq0L2WcFoBT1s`6ED9^gG1uD&*Zok*AjhKpc?T$ z$5DCLJh+XKZ5(;SLdB0HZZ48_NG#RiIzrHkO*__BB>lm`%gT~bim1Y*h1YM8ZN6g{a3#U=(p7wkGVym zYj$S85g~;Eg@ok@O}nwN{kl7^bEu+ohReA;@Q0c$FcquLOiK|Jj!@E<77H?h+&V{v zJUS)^Co1d8G)XYX%rw6sm|{u3756B8S@baCUUl)X{*8 zsw+@iDSUznQdAOoXALX_&tF~lq`)c#9~t39G6V!MDVzqFAVr_wAx6j2LH#EOT4llp zr#_QSBnbbuw3C6!m?}NIdt$Xk^9Ey(=E`M#-s#w~w1gc4qmHpO{Wt3b-UeB0dHmez zm0B3FJZ|j=PminzMZvlEK zeRaH9hJ0lf4*ZFW;KtP>HLt_dLU`4$k9oH5XitnAKpdt>zHgNvfxYNNDglVs?u#|N zKYkFLCV(m~8IcJiWLf(F4Yjn{ViD^Z>f{C1U*Dl3m46?^211m|&-e zUNXja()XvJiOEybz#?y?ZQKc)fP$WeG7ooiExz2(*^FTQ5RNipAK=SrsT96OvUlgV&}E& z#7#4k=1+Filv=YfQZufyg~cun3969WG4=!Fkpg)^Wb*AgXFzIvP^fT3KiY>OhB(1WFfpYumj5N zchrnnx=X{F!afLOR_<#m?k$Xcd~l$`{_64m*e-c+Q^Bp-4H@=4)%uGwFBu`iuVFk{ zX7{?PUV^QQlZ`(cYbWIY1tY#{VmpuPF5>=5mVqKGkqr;(o_o?$(Puo7EfwjnmO|6u~l&9=u zuB8(t9+3OANTk6Q&YaDc70B&ndZrIw9$!!IAHj|lb;Wdw3UHAcDl>tv7i3dkdz=Mn zb)5!wYC1ww%5}>GI@@Xsoy(Qo9*)#%>ROj<4};j1nbx&OSBDBYwF2fw8te9AxQ7XTjt_{gZhq*_94&(`TL-K19D1{B4(@s4!2)MC(^^8y~ncXWr zhmA$O+~BKD`#ut&GG!7s0m1FkH*uoG+@K#H?bfIoJORs^1hew;VjW@>gv=fYc{Qs} znFNzRI=S_Kc@SLQ`(vq_bfc;!>v0b3N_5%&6q)BjkuJ}7I#sHB=|pZF*uTyM#))$# zYI!M#7D2}UavAPzIQC6`;whImcGVYHmR`4XGhSg>$W?{ZQ4Z%s8RGD50d&INkJ-c2SL7%q-T8o79iQg<#_`Wf_)c3HTDwmuv zhwgRc9p&kY2c24{G(sg#vQ8!|(0M{Zqti@gT?hP6P3cx6l6+kjuRldVhOi!Q={_SE zwfVg;oD7NYdc;I-P}|ElJ$I0kAZ^M_kt9}+q%R&2%MH-JYimCO4Nkz;4vwQi!3UkT zjVmTKcFV<7r$7F26IVeL8mq}Fyg2EGi=8SnzqYQEAn|jpDx|f2TO;zO1i)-)&jjE& zPc@Bwq_vgGDV%y%kevSV8{EDbrkIt{^m*IE;P%tr=1jq|f;S;XUxZ60_B->+j18Y{ zk?fX^H2}STB;Ak?vFmq__U>9X``Ce90A9_;?A8OfIB>Yq?G~;gk4_?e2^GFwgU4fc z5f7&^9~!DtGrw?ivUL?2#&)qAP8}d3HG7OA_YA6s<9y{M*!wk=JVIB_f*o_?(dzTX z-H|s@`W4KgPuS`GR2`QN(|PSd+i^X$Hj!{+Eo1IL>2HUMi|FC0uR}PVwoHo9UarjnchtQ@c89I+G0ZeLl1(bRmdTfO|n;< z?q@;Rv)}-RaCSH@uC%ZcOyie)+(+;}=m|)c;}QLnPf|@Lh`QLc^hFDcg5-Bs_NXcb zXR&(!Xxb`-yQyAngr$D(t9NU`?cwYxSG%e1#*C_>fX~?+S^_fbJMbMtJ!!s{D;ssI zv^8M8@mg4s=Q%#(o&4pdi1Ewl7%Pi{f`T6VxwMaL_TbY{M*t!(QQusqd z$Vi({K>LAfK3DaqxIejV+%@TVOol&(Ut^mnu514hP-n{Vr{kZ`<~yI@5t6muiTQ_S zto*%N6-!iKn__Q4>}k!1I&lg}__*o#F|KFAj@aP+n&%5aFd?a2E>oO-$-NX@(m%`R zSY)8}Ci!C^WNd5qkeprF!OqY|tR}@772do1^CFG9#zawvd#9-%sS}?K2+8pkD4N1_ zPiYq!+|UAWa>YO2oBqBuprxdon9ramLu<6R8_+e_hlY>SvRKMiymo{-eianh6sSkK%#shGatTFdei@HwknX|?Vwn>GR6Bg z(A(E$5a1_Y_M7~SAc6W6@(>gSZ#gslu2jpCN>Nnc~7h)uJN{&6f0{EYBW%oVxPvkvg#xf%#%> z_yxUr3wGM|%^qbTDa%y-4b#Bkfeyow|F7TiP8HM?E>u@!r}7=j)XV8o)N_>oZQCUd{2f|0V}m?J{ng8-z}w z4*I^62;6e2kb+(z298vAuTi;?r|sQ~f_}?0vBz!|N<#mrz~RJ=WA}1XR@&uI?GmKh z3+Zam+0$8v`2**G#Xr72fofcfCVTQJD?wUj^D(D9C)>K>H`3b`Z)q!uPRCbq8dP~U zF4m#|mc1Ba4#p%7|NU|GN7eJ2TEdG=NUtl;t%j%CQ%+7;7tNf`TtRmuVmWTNB4Hu} zPMEy?cuy8SUVfM?w@#EBLu!02;;pxBcB34eM@yD~?OA)Qr2UL#tAJ6Zsi63D4^Edj zoDnB<@|A8GO^`WnlBvyEBi#}7rBSCjPypWN_D{aG7i#m)J#n{Y zn4^JNxHvA%P-l$xBvshj?roaxq7g#}+Ezt>g&Jv}rp)t0kg0%&V6h*g)9qO7e!Kf{ zs-aQS#WJWVl$?I)#DiswyHEXDN4?>N_4;OdG+IjM`|9KsC`7VeQzfSv&6Z#v9e zfcm-HlEpH$TuFV~9x!`ZIE6KWnAnY2n!Qj;Gc;qnqt67Z3KWfnd8@Nk-2%g;71`xM zjyIGQ5NXZOPuuHJ!Ms`9*l&#jQ>_{HkHAIxm!C{)KiP9tW*Oh^DEXK2`TtDF-WU6y z+)B;7xjukRqDOKfM7-Ji2rBtU`AL)%)^?UgizSZ{0+FR^lutMI2U0fJ;W6(*L!8<=>H#7uCIW6X+{^++d5m8a95rGG#jf4R5&l(CLO? z%~Q(r;mF|~&WTSJ)blY2}hZnIQ{43apfkF>q6Y0OzVIULn6)yO@a-s3PEauKV$Twc=IFhTn5 zGMqaR=lLGhPWoX&E(TZ5oyIW1m(JU5r_RVa3DjPX35FNfpr_NZl;=)wyn}y7;ePld z_@w!&Asu-%Fs8lHj@{rOZQ zIr-t}2+}APq%d92!%=*M_U<)f2O@U7&)j|q|Bv}56~~6m4nHrpne}Bmq=&~;5bNGR zm?IV<{5;&Y&XpsgYg|*NAoQ_E#aeFbQ`8SzD)&is8DosKjTmA zEm~sTQrh-UgV>){-Qa#N=}o1#o_;`LCa1TLBq?wg!N#XPdkV&0Yc{7!If^?xiRDLx zbm*K~R(IaQwR1`a8N?TU>Z<3+q_*S!&?m8Au=4@VMwON<-Sbp%O(rA$A&Ylfk3R@& ziJxpNQUC1>EioxFsy(7*;5}Z6V@|jX@OI^dZ2DvATNI!;SN)1gRWJe9bYAu28VDGk z@dFUV_h2TTU{=`pb!bu&imlULvBy|{ZM1>_SGc>&aD{7s5W_DEXmp4g2d-<e?K?ztF)z!f{#!=v9Lz$ui^pAb0?a|ygw9keXhn~53Y=v6}PNs6#YwpHWrOB1-n{%+9$JDz-6CIrkJ>y|Z%F;IsU_VbbqSXSc+g zS5hv`js&di7lQb>G7%;K4v26~K&?fU6%KNBQ^xb}ie;Uk>8k!s$#u&5ii8(utT>}5 zUQ}QfGCb*?ej>v=f<@GqpTyM@aia>tt$S3q_|eXqj=o40?6R8dZi7J)E}#F^IOt=V z{@nCpi{@J30qqWzhQGc6+5B}qq&n9(O4*$|_H;Usy@J1m@#mb1E!02W(7#0L z^5GvT`tf|WXn3fXf5NP9S_BW*e21kl7lW|D|6VTr8+V>X$~XH*?;xK6JW)D#40KJK zok$FHd8ZVn=4IbY^ncC}nfrUypAdIxu zaB^>EX>4U6ba`-PAZ2)IW&i+q+NGUWw%|CjUH>_XHv|GC42J{9wKM|_Uwec1W>?qi zmef+Y%*smx6Xu*iMDSSu^MAa@fBn~ggzYetyvZ`3KMa{Tl1v z9`y5~%Mm$*`SYOX=RsHeeh_{h(7tJ%`KjfvQ|Rma_2>R?8Tj|`KlRyT@nPT3{`UWO zVfAL>Jy(qD3fIYhukWW`t#Srh+ce*Kq!euVU|cV#dAU*3GzpWns5{rUWM z=Q#hi`u_XAv%Y)I%%a_yrOrQ-`kl)D9oKap<*Vz#(DGUMH}QzF|9<$pBGm&?nCCb< ze~<8l$acNq4l}gyhP8hkVKBryt|JzH6XRgh{KI;c_{4F!f46^!Hx~AAUX{HZd)x0T z{uxWyuYJyO?6+0kJOh`;z{3=Q|M>6YKfU37RfQ1FpT$Qk7*~ugHp6h|{4bZW3E}-& z)U+4)_wT>|<-T6*U~-jJk%xut-y?bo|F8tt-sp=96Tg1D9LoH8087NH6N5nm?!c~v zD}@}+5@QL0g{*8)W9TSQ?Cd~DDNY6%@9WC!O^v>qTT0lM#uWMEgFnZZu@mXaS7C3^ zGB)eJ6Y^8;iVU@Mr8}jRQ%N;FspTu*Ipv&7)+n}emHQ~E;fTH~FKCpYeHT+mvN{pxp5N6)?V+MnJA;xq1%MjmC<@r*X(ye9Tz z=2>Q)&ul9!L}}eCt-Q*r>sjqZ)ZXiO?>D{qEpL6FxBc0*@T0bW|NB4KweYiRaqpBD zmOs13pO*6bh@d%1?im{vk2|pA#VtUfqkDGNaNp6LbI;Bvq7^AJ$mE{Q;Eu6__X;t+ z;dk$j`0c1W_y4tTN4fuL-{Sx4&K+*uf4Fo1ec%4ou1($0*gN)Vp^JK6XdgdcwZ+b*XF%)8cg){z$$aypqOU#YW}p{BD}4EKwqr2JfqJ!M(gc_d+_+g*tri8}Z1 za9-c9$N9HE_<#6yK0VYU&$-4Eo{63f98bK@@uCrRrjE+wH?KF}b-d_azMk=1{v69|;*vZ0x%VA~G_oQ9AC@2hUz#9{i@pvn%q94=m|=$LblRqeXl22x%n* z^2!BazylVxJH92}wT+BD$+g|_#ZwZ^|{gg^J@8EOM64c z5~B`^M$K2e@1dYhyz16=e#U0b_Z+DE725i90dCa3+eZ_h&d_i#JI-z!> z&#A}!AOIKs`$1>c?~f4zmUE3Zp2Z+eAAh4F?a%Y$jQgjk_rR?LZ^zlQLba4yDlQK z9Q#1l<4Eo0|gE#P_)6(N0DIBSd95)KuLrb=$3}!%BrdPxpOEX5P z`zeg{D0?6eVshg1a7P%gvfkep-MBBFF}`PDZt<50_gft5IN1aU#C5+DrA4-T@0jUY z0}sKlITkFYTD-8HcgkE?ZR_U`g?w-Z4* zC%g9|y(RJQTH#_f-+Wzdd$N^|crR2ZU;z?7^C~FIgX*<`Cq@?9UQgsHvrG}ZqY;^? zdB_b>xUN(G+wOTh9gBtWPvKd8RcYBB2IHd=5x4LtnZs_<6?|yx`*JNKh6fkIBEWV}RJN zi1!-ba3~?j(JA-Oo@S2J#>QX9?lh=tG%gT;Jk_2VA8r{tqU{AVn1kHdKVAMxu?k>3n&dFx1OFCdJh8339!~1;~LQ25|A7)l7rHk zmiI0I7Phv68jheVgo-vU)=n?oSFQhU~pfHXU^?dQPObMkI z;<1*z{RS?UoM7NtpanueNYRY8GOK~?t!*gk4XAx4Xpx7;HIZz%qQZ-O^}x2js6NZq z(m3&h*If`m*5yjrl+qxY$`m$bHhguhc&pUz5l~u?MVP&>32rO-0`7vI)bmk#XNhBL zXjVcBaq4GB5L@IqXfE&uF~pKyWgSQyus4M?d#M2jBinpG3!~AfM(qj z;}2@im|lgOBc=NmdBSOviXaf0&Fk%vegD~#7)%=Y|# zjAMTO<~Y!^#~%V~<~x4?NvO!-nMyfcY%^}-hU%}ET|*UfOxLp z1%~{>?EvjT6<1?ZU=WcXU`HNSHEf^5B_UuDpkSEr`^BP*MJ7@Vq<9V}LcC7k$3)3* zyvZpo>4|O1`igIST{9o|{m*tb`F?7i!mR3|VAv`ud#(6$w|7Ra`T6nHCU6EbjNIty z=Qf#7-&TIlV$BzY>j3ry7)EKZTbSI5XM%{zr>+-91>-=jlqn7C4HB(9znyFcoPFV> ze?3h+;2bRjS+Ok8p@m$=@?LNgEzbbD$A`Tv;t;GIVuAz>$-#a*wh7C+f*6uD#P>W2 zwaR!#j2vKDn{mJA%n!_l&0KhKhl}p8#!wt=`UG5H&#{aPKywT*6l`o=cdz;^UIChE z%(xEhDDJk#oZ*0=k>@PDqP`%u69+k8gc*GqrCj9zCbuysfQB_?xF}N=`0y6I!hm*T zYiAlSnlZ3%3pjED{+i4Qb1L^b@j*w>fWP5M=y%6X8Z$I4iA#i6qs6+ z8;rBUvf1v=T!6ta(FOlICx|2|4Dbwi1w8(ZtXdQwJaxYKP*x-xUYMBbzyikOx!FXZ zH7*nA)8Mk5!6!H!2EJU8eFVL%=ClCT*fb(@cA?t8p(KN_-c-|8b^Hp{BOtzG9XN1Ct&(nlk7$-o*jVzTQ z6qGij$a7xvJT6Q$e+X#i5{OIZ z-sC$x3FCxMLf)iRGI?+Utm_5Gu!XRubLc(_xSTz~AV$C!h>gdzpU3zjNuG8APZZBn z-h{l*Q5nv}z~BnQxNt#0eDFV{{yZf-_tBwncqCK~_WtLJNBC>_2t0?Og*7ATSOQ!% ztA)HJnLAKlYF`}d0ec!x9Y2>q4xm4;-i+%uY1%_+Tn@=VYrvNU)5HpRFLyf^Z z*v1o?1xsf%h?NaL6rVL=UkgHB+4^$`-d;JZME{MLO-389@nH9!XB;@2U#5@U|GP76 zScE#SggM*3FretDIuaevg-f{sr!TSts@=w{K?ET;j2L9F!-p^sPfWa~ARDJxWjiWh zC>nCT+Z94`ji~o|r=zdlGz=#Ow@vT`R2;vAivPYsj^HaAOV~3&^qvnWm4(HvVZ>m0 z_>TkXy2=E#VpZWUFfpdn7M2yt1AW7}^f@Qy<3{2tepT}V=YR(?TVC{lxfTKmv|N~Q za0V`{86gU6**g(<3B`hxfcnF0;DA5w+X~=zU2+Tx0-h<-`%AM2=25eMr_?jtd;XbHX4M7n30AexESC9ZLeMNo z7{>3FyWr|OYq^~?@F0wv1zczcs>VuIO!SLC!0=D@>4rYf_GrR@*W-YQ;kAO44+G7g zwRKh?JOG+e;;B!pP8S)x@to3~rJ8Yr))bLg@zVYt*M(mMMjGDDX|6t?I*5G?;V*+Z_X~0Z~GtUi5%#1!hp8?|~pj9m_WnFh|~Nz${=u zAidDWf}52Gfm{iFz?q(!E(B<_cl_L3A0Sg&?q@&otE^uM-y+DY7mAr1{ z*^2sNLJ;yj6L=_anT6_kD$Ba_8-sr11u&v;F~E2TylgGw_{`@3dGdC}5caqu^Fi$Q zXDzUewMwlaKHwu(;SSib1{z`e0T-+V^yNHs@K{gGRD3X4mvg@{Z2J~O6V@o>z#|qH z@-Z@tJ2!BTL__ruNe$J3xm(*OrXQcUuzTD4o&VxjgN8837O|qhw(HV)4c4F?Y7-V6 zdW;C5$iR>~&u8Et`;(sM*+o{$kGOVFA(Ym@&LV_ynJi8jlA;ItAp^4KT+=VxHiap??46tC#D*qNpDNs zz#qXT-t+wv7{|&1ti1*B_#E-)p2n40mmQCMVP5PoAQBm64exOeuqTM?A8wI#e_@8G z=kwq;k8o}qDFV2g#BX8>d_XU_&{IwZIMiCfa5l{@diaIie8SExC})$@@PxV9r9;S= zvwC{0QVa${T(2MZZLr%58+MSrxFDE^5&p+W;+YoA0-T=CyYbr}hX`Z_?e&`_6_y8E z$2dPQxqcYI6PGgkwa|sRSY)7I3pm%u2lHZHnLOshdSfx}*C;g9RC92~2yATiU`nsy z9*jaqCV1;)V}mD6_`Q)a{MEz$JfZ5n7=r?^8*N5fJtkz9Hwtt#tdH82mx>Ff(@c3W zToK@1_r>su2yc*2IjhW|!E4}SEjnzBmB7=UxY}umBC_xWCJ&4ltmHVclBgk68AgiV zf8Tmnw{;?HfV6ePg@HJ@^nM;F73^k|@G6eH9AttC0Az{~XB1z1NC#DB#6~aPZA?M3 z@aXg=PZ^(puEkdpHlQh*Xec%ad!bpZVS={wj01do&M!Xu%KDz%z2VHDvJ20W(V5tf zYYkqVfKazV1I*wwF8vCZM~hg?Cv=Daw2l>E6bXdTjY;7v3T!=1Oh=ZBphsNqQ5-a$ ztqz8G9^ZnkPntjvf1im9Z-8y=K5~iZzh-fah;aj$jpKtAV5x$sbje(WF}}BRJ=@XC z5r5tfgx-!-(*&Qs0k{~ka5rdpWAe{FtBygs3rPZQASFOLeKt(=0Yu!odnU+I=(ADl z3TpMZr-b`yQ@`@U<3DH5UZL%vdG-g00W&JD$9*J01~B+E0)ch8!_pVw%?h{#KEW!K z6A^8wYLP1WTHuEB!G?mq&ojGgm*+HM4AgVK_w~I6;=ft|&4943dPDv2k)9;--iP%_ zt^?|N0b&e9;@6NXZ0HNDgr_e-#)Ta*qApm{cY{l_X$Kv-$JBpw;jhoxV=L%iJ2b{2^pn;$>k^Evyd>M6OxD!>o|=~}RzuowJ^fdzJ#&5cGq z*e_2b%^uh|r^44@?&okytQmUAeuIm;N_)PidA%^m`Z<&GZpdq{Jgo;+j7nC+_Xkv$Sl4w)4LX|=mnPuvsO0A`#8 zM)IZh8qZ|t@q5KYs)4H$U7Ust4hiWwPb2gY2$mCw{(vXm%RuXO*Rz2KZt>>>VtCs` zoxzL`%vlrq^o0*U7Zl=SXv?Fz00H!Ln*TDCx&y2U&ieE-Co$WL^+^d>_y{$gml1)F zfJP`SZh=iWjVc3BA+$m$>t24t z#)#ZqF~Fj}SJ!Rqvl{tG9;#^W1}nL+qDRO24{m<)`C@^A0c=*3t7p+0YYn`sc#7pp zB7U#gEQz&y0ND%N5D=zw9GI0$2b0bSQfHBwwm9o4z?ky^ZeTynNfN4Mp&C~(=o<_R z1%|-s_VBczsB^1u$A7R=Gu*vL0m=!R59r%i-yw$Kl<++SU&!X+$G~F4L!1Amh|T6Hu#B#E@NKhNpR zsqRYvZcxC>1LTk$aNWm1*!exDc>pfhpJ$!KUT=OCu7)ZkFKy< zPd99p;5%3ho7O2MmJ2GS~|83#{=4B&x^8`p6u3NmuDrH9>vqd;^`rGVO3ny!y`h39tySi zIfw*4;7P}Tg~Y)|A_v@RjJ89t7E{Jxj&tCuj3#%5kpK0-7yO~Q;h%LrJVC840AYXy z?yq|E@!*?5I%mN_qfaIr{oE!8^JxbPczQ09AwfvIkn}bz0O3J%%v@Oa1u49T3C!Ar z;gRV+CXZmb3n(EdJd6r?GgNi5`6DK{5)cG#kEh23T^O?IK^Hb0BgHceixuGfdR}A& z0eCQ12NVd`Sdg-D_avZwT}^-lekr{s<@G2RoBST<8nr>JuWAX=e^0~mK&ay~VF{ml z--adGZFs(rjz>4bk=4Ce6>meXq4^#N4 zq^~)KO{W`-INar|dkG4J)_^&ba>u{8;(%R3p3HV&9YEtKIuOeER{|Tt4Mw~@821c9 zf{|8Dyz9OJ3HoX*fY`boEL#GeKRgB|JD;XY1G=$F2-+OaHzn3@IH)dOS&&gUOMuu9 zsVDF1hr}uLP&Pm2MtKB}0@j?K+vHnLl1X+Zv z9WTs~)ut;G5Q&d#-HLVFIhTSxXb7GhhevRLOg0Mqf_w$RB0!$t~ zK|tAjS3}G$7e&4A`?>F}eL0^Xhp3^yj=}Zu!qbI;M&Zs))Jd2Uyo;e5w$Z&Y1$*u^ zm$&TjM@I)Ia5BT=aL|$(G$kj`77SKj+SCSQ^QWbSoj-;b((N|P@C`e3ViOwWn!kpE zfIzQGJN8P9TNaIC@p6VPdd68_h#wvw505M{Q6Nt?t!Q~N@@zN-3ybkOJld*JdR4J5 zH$cARTmA$3cug}^^pTWi?jZ7YvK1KAkt^TpAkw$h5kROxn*g-g(A&&JN*Nx#hp(E$EdAJHzM@z=N;9y)%?}qjODt%(} zfXX04UJjx*r4|m$G=By` z$q9kE_Xwt`pGIpLfs5vkvcL(HXPs6A&pNvAra60*VnK@NCePN z!8FYS_JKV{v1MDY$Re4S7FT{uuX$2lA*J-NLYSQKCq3?#0krF2OJi)i`~mr!=VJme zSSIk)#W28Qc?V{S>7KVwC|YMMdj|D@18-{{=JEab-SJ@n1=w9@b0fVbQA{HmdQ-lvn?1B%h+njj*#XtKs@6Nn1vBWd29U;vfK!V{I<@u1<0TjdM zJL707DAIA_L$N38jz7;}Pa$K~XY32i0PxfrR(6}z!M?CYtX^pwszGkT36|j+2eNUP zDIgAHdd@sLei7HfjP9S2>?9BuWZ;f)F|0_?8LrX7e#^b1bjcO*)CrM4zf_Zn5be33 zt}F=jEJN^E2;33m6O%9kqW-|`u^DI2H-k5Xo+d0H?x4{V%a5amCH9H-TxJ0{f55>3 zH+q5DU>ea)-DLII2eHs7d@~+xi9b4=)GUp(Uk04Zj1vHC?7iXqfPTSfN!24_VF78$ zTqa0X+;5w4N(CTTObv{OX=YW&J8ujVVq>bi4)!n@+c5?Y@Fu;jL3J}rWGDxc5C$et zVF&r3b(l|#1pMO4c#>{{PoBsVqd2PhASMEuPF#l39w-U=m%X{dIz1w?hH2Ii8-}-S z@P_}58+IWc=0L(}&DexovEtPvmw2aHMSl2s1`r0Uh6hd37;Iv7aq_4psrf>kb%&K(ol)X}&)dX%nA(X9h#*H2@0g5e3f~-oy@x^JM|0Bgya#YA zURwj#Mvo1BhgE=`c#8SV6a3f$7chdF0l@GP+{Cbo3}*|nXk9tFF%aEwAi&)-j^*j; zjoT3YS3L zJ;uQ!UZx=(SS?I{?*kxdk>h#0(Rkiw5+t+4=SE{hKo0m&yEhMMhEnvhzO_7@X)%&%JT$llBE_{0xWc@ z-$Uf*@9~k6oJ??he;<-JFkF_xY8S$b^@6y6Z-H0+z9U9ss2gz~I%Ct$Hv|dK&p57z zw}hhYi;#-1=qL8=k$)d@Z46Vw0$#wfJ77HTqLY0A{zQoNO*WXzv|n=n<0WR3p1&91 zD@<;WK4^j1ey4&>{oW&pks{-eVEOQi4PrJv`yJbf;*;WPtZUB^Pkv1gnGea7X`1@0M&xkr2m<_uU%lm2j;4h3ykJZ3tU4G-E= z4j{>nGw$a&lH_g`NAf)<1ttO)*-sIlryn$fUK?5J>4a>7vq6YVzwgn!5Jij!ivkH4 zJ4A4cAlD;A<>xOhcp{N7=L+lw(;2{eI)*KZh-Nko2W`1ro3uw;f$3$MQ}K=ToigF? z=VA!6p|YyQ__^e8t1naA|MDKq!(KL14K0G08;KyY%tokU5|85gpkP}Du66hb!2QJb zw-P+Ma6N9}kfmxrSmqxWV9A~Z?8ObeCjJ2?i<)ZGzo($DnQkEJgGX?$c!GO)h2C@;x*Pn3 z9o~^K=By9WWJ~gA6qN5&sPltR`8v9>P=*GygRCaw2I<6#3ZXV0wqnhs($h6#_0V)y zG+;$cqU?ys9`7qZJ?yV)0(|cr2vb${>`WL7+rAjJtRcjr$G&scEq!b^&wUknG!ZlEhxU zH#gzS+^r%|@?F3&FbuMYi{_n%>SEx@otsLWI2>Vj%PB)0pD^qCsX*|Q=I^x! z(4&+Ak2q9gG^bHrMDH?BBOVw_V+;++#>6o!%))~DSMeNvfIYTM%^|Lxs>7o|e$7&# zV!;~o%FwF=-`97rtixO_oIvpnMQLHPG35!zh5)cXA?EV)%+?+lH^2gF29!0c{@#IQ zD8jRIMaw`2J!7g+Nw_Skz5$5~C9^gMjTQ6Y<}zX50l&NMD5Zj_+d&Sf6moP0v%?T{ zAQc8TzKATMjU#7h*iR$o?21{QXj4~op~dwulzD>3!DV?|{KjN{-w|=LoBBh+Y7TnF z#~{@|&<;NzKer3Cl3*tS!KJ8XWtI8?8D@fY87u(nSWxJj=dg&VIE#r<_s|Ov2!R8U z9s`4EP}49*;(0GFNUT!BIj*00%PkSx0HIsDWZcw336K9a%6Pjr`*o-dg#%00)mTn+ z$Ly8Bn7aw$U6WvRw%1`%Qj7RGNRp2mcQD-6P?7tuZ@dAj-HHS*VBKyEcmC_o(ZS~f zED=YN4V_?gO~pOp##xQ)ZWQ%%1Xv}Qg25sfk5588Mu^|~Sb2^FA!N;>W)Hy-nR!&~ z9hM7SV`_+-QXyqy$5MqlEXS422i`v{C^QyV<>U6{-Pr0L^WjMgmJX>qhpAi@4urQX zu*xA4vR>zv&H>>q%HUD^5F6XxB3|nbY2EBCl6_lo?js;4Kv0LW12zuDfX(kvL@-t^ zz4=4J*vDj&(}!{nEJxYLa5EJP#KKHwK3<-upQ9n*+J%0W=y^Z9Q{1!9qM)SFoY7lf zHjXwLyBo~gO3EPSW8J1!IQ(e|nI#@ZbnssN_Kog-65FnnYmU8uH_LG?nX#jC==a+I zx25$tJx#*{09!EMr&4DD;W>>-BW&x&Eg&g~-!Q!p!#3gqWj>zPS)yqAZZPcK@c58` z!5oYXm2TC@*+g%wa>tZd{+Y~^1biLfCUpwCW7WNVNUoikZ=At++44Ze1ckWEY0}Dd znfGQkNf!isUpz?3|@^nUrLl zRC9Tz<)f3*Dg%ayWbzx^jsAf zW%Me};t}TsI2^~j3f8%3b>bQEY%ZQq)3X2tcb^4%FhB3vJU0W%EY^Gl>9gJugSp0$ zPa_cD>)25vkQW{bV-w94h*-;HuEO)o)9}W4-4qj7d-8Za;lw}^Ol{5t2b=gy5!id) zj>mY>8yj@y)owgHRD%uHDyC$Su|+ugaB1C)pfPG zv$xpcdk4NC$E9oUtZY)G!>vgfjxXWiFcjd^Vu4J?b+9{FGt6bcWtp{hyYv=>}A-;DHbj2@ia;BJu1;+yN~~NPA76GEwuE{^ee=0M$Mfr`=h) zkp;LQkB^q<%JFC3akq$29lzt5MnZvfcJheql%-m=oF#zdJw*qQEJm3|w|R<$OUv~1 zuOGoxkN*}}@^mTod3&JpOguos5}ZhA3yiU!*0q2WOYx{0S+Md7;|i?7ya82a@LbkX zEc`6j*rtM&Fp24^UrDz0)6J@gq}#Wk;I(>UvRU&wKvO0h0XJ^T<5%d=1hd)_UMGoI z)_J~7r|S_7n8duxEPkoB0l7RLPX!ElF@Q4aI&->etT7=p(DkL0lm07!h#&AqRD}(i znDfA9i$yVRR<6_szz&=_^R84krx5eFVHmiVr?nH?J?+ooS-Dv&NFb|dVJaIi-oZ8E zqU$~Cb)}siF)p}Owp&H ztarx$R{?{8@{J#j7Bsa7bMS(nVaGO9aL7<|jN}1Y#&1;v0-YOQ_**oqn;|eEu70t5 zp!Kh++omt;x~=9dwzV60`Q3pp9iZd5Lv`0}8JK5KX7OR?S!-7R#Tq{CsvV-b3?j0# zrha8J9gNCDQj8KDcZ~KffDJBFpT;c!o-iZ?vDo0mlSq)7My^gPi%Lx*%YxK@a+1rg z@k6qpM>AvZFB9VOJx@X9X>%Z6f$f;3nD+Oqv!BKb?2FF!!~+p|nRV+N+}GzcoF zZSB+ZD_f@NxoUq+8QV{AnR&niIZMq3Rrk9O(aL2i+;Q5m<(f8H(wZ)-g5?<3c0L#s ze0#s`N^tLL@dX;e@H}SHj}npKBG57$I_{jBj(yF$UIs1@uspnK7(#_-MEibtp60}? zuA2Ccbk5se3YO*oERK9L6~G?S(@m=#b}Ly4Jf*&5G|}2?Fy8dMw|ZOz7i1%Xg_`98 zw_~GV*_xVN)&B6ZP3{+WVLn2hCZdSE-yI!0Pu*hZx~M0g6LqmC)&MBuf)1o6fqs|8 z!yXh$(QF@-i%uC`xU>r2y@g#e3=?kn<=K}xuA^5VAlp9-5iif5AJamiMqvFhZ z8R$d?yDlL2X+7(K^Ya7*jtFMOu70@LGty;Q4b~s@1ktHRtUTiNz+fT|9%8#1FWl40 zgPmF45xMiSM(1K2PzkKtb$>_`cVvku;Og<9rF+=)^MGyz2UNuSkNp7b1B48K)ps(S zxx^1XDq7=W0r-P>*&NJXBT0G{teu4y+c>k>IPf{zy~zN;e(Vv*G(H3AIj$qXPir!+ zz!UCjJ#&9AA5h261u)RK-UG`HF4$J`d2rX=8s1`VbUZy*v$MefR?J|#1})`%4Jg#k zQrl^cb$kEAY{24yszn<-=7~E%iZN~m2kw}yW7-I~05z?mvudXs_e*t}tBd)I;dn5U z7t#UQ7KrEDlyD&TxNi{9$pbOEK(!%Y5(~~Zz2-VI!6yqQ5MC4<b51`1&M}?wTZva|N37n1gj$SFitqAEdC8HNrTyR5d(0tTCCWecNKr z{y<1A>cI~&0cm2Uq=2~WIt(gD4-^AK_8lq317r@Wo_9j-@OL$NICf&t=Z;rcC*j%0 zW8@4sJ$JyqtrN8kkL~WDQwUi&(7Mw?wP5oa{KqP}ft+gH@ehdV^9Ew@iu!GwP>7gM%&q)!w}uhEcRF@;v4swZLvv^eWEZL zAsln;0szzCCJq(HQSk=g&%SefVe_kjQb9*}qilg~28D-vSz-eGkG5|E`yIBSSte#J z#-fBz`%bMFybw&zn=B%WcJJm>f?=EQ*<}S&4*>JPh2?tggT-$l@1`O`=Vqgo>B;c> zhFcaR@K09v;#OO*K`7#y-{;&lV{GeHt#&v<=4DH}xAIpLo6rlOC<`}GK#|(>sabK1dp;?$fp>21xkC87MXW&yY)Gx>x1YkRh zx+GsLF5U`zg#X;AaW$YitR2hGU2)%azA0K_Zh@00e7QUEGkL9Nm}sNjo$x}3O%g&t zvzBo~>rCIVQ(L%Ye88MrHYTcIJ3t%!9MW(XP>JOS+%m(?(8M%_8N;#y{6nT@=>80P zl)70l=KBQ5ipM*)Q@~}l<0EWDz0PvPVxZC%4jAfy#YMmHTg?)ZXzV!vhdz+(0ZdBf z3fW=J=8pQQU4_%)@!~>6UF^jWa?UJ^0qGRGv@|3W%N<~+CbQeFLL&_lfxe!mS zCGS7Y$y+!z(_MNnW7+;>Cgp(^Vwe^fLDgh6@3I*DwF7|BK}OKt^WmS>4x`Mo-qC)O zsg}I#VQ7Sz_v35riFU~{H%r{8TI; z7oc!2v@==zeFxmIZ|h22a@c$uSZT;E9`5u1NCiA#OgLzo#C+wPqX_= zI;s`4kEfvL2i(ng3D52nZgc70^vtZO^(*#bbK=d)WdpC~NZU#Z#KzPk2nv_<-Mcox zw$V^t=#{J+JCkd{;Qtm~|K)NC^uj^FB`V>x`**D#{;>>x@&q#yWx;kh_7L zk1yNvV+p_uJ2RYmu)iIqH@$pb(xN#TPDljDouZiJI{R|9Yp#`?i4asHR!x zWS;`tui`}YN|z+-%Vs%mFgtJ|0=}$-5}$WRgnVUN9yKIw?(-PS`v1UloQ@lccH0$Y z-=4!}891}!$57d)3LQ2NIft*fj|+cp9}W!e@EtffE88pGW&j`{2e52Mp>vGj*&F>d>%{$xPl0 zSXDQSH}IW)ar|a!mrxH>_1cJgKf-H3S`F0OK#d6AdT(>r*awVN@hILBdL#|7XrCx6 zjC;X`od$&ZVMO0ZjZrweeeG2CrH!{r9G+s1%eF=)5cp(Jyt#!xDBc1G6EBaH_G2!S z7QhGA93^Y#G(^S`jUhXn_xb2V4L1MWL;zlkZ+Wl`Ygn7*xotQ>^|nvA#IevZGYTzG zvccHti5(Gq4@vV9hJv!`H9h^-FHYdY?1KNOTgEN2>5v3cda z%buUXpa#OT%#B=D5npy%Xe{peSysEZBF_0dEWxzGZDaTb-a~fSU_qm~b++BaPeMF) zY-T>z{cw4R@Hvg|Uh&5i^HKI4YWm~qh0aUm=+DM64 z8Dus(j@kfQu9nZss;gn5@}Kv>O6Kuy*CY7q(_%{;FyK;# z+-+`TSO@fmc!{)vEp_aF^m8ltBH5X--#`4wD6_~g1WQm*ks8#JmG0ZKsC!SrTzP0s zU*-klaOIi1ovqD4Wvdm36P6WjHq3_195x5Vp4%%KCU}SQO9enNUSR-`20zg4&hV98 z+uB|~o$tVo*$tv%GZqiJn3io<=WVSyo|4;7TdrOhya0It=3_M_bUJakULGG=uxAER z^$3^OVQ-1R;>Z?uT4!z$p$Ws8HVM@PPFrS`e|j5M$SzgMs%ESBYDU+Lp)k8@(J|ut z_*IW*zizjWZXslk=fK={h&1UQA{qR!hW-yMQ|+s9u=)tjv_|{=zIw6qK=VE_hcjf~ zU{ERIA^o&Z^Z?HY%Dk~mhGeFt35QiMEL}z4FAqa;d0{u;9-3l-yEz^C+Ur{(^`54}j@>`(3do&lBH-Zrc|G;dYgqhxSdD4vf(?y! zUf539lc@%?7_G{>%x3DlhzW>qc(AhYCQ+FH0sFUq!4dHkfW8_7;6cvE^4zP~-85jS zpD}iUGNj!0dpv@XOq+5|E+h<^cJFZ@RUL%XHzwLU=%ij|J3V;;Or6wg|iA7Z-%9cKbG5ec4RU zf|-hwK7uXL)AM*(YMD2?gazuJ#$EeE5Bw`VnYNm=|F$IrCX-pYWR*)@to<%L$+JHN ze2pwukAk1{Gwx;c%!c%E3yXs!pt~Vim1EpfPTxShXTdhxi{F}d^mLzSqz(q2#|^`pckYX+hge1 zk3P+f3ru;jwV92j-e;xrz)hO50UR?nXiHX*A=do8AZXrW2*4~!OYO6uAI*8uZoH&9 zj9}z0i9Y;f!Lzf3-ee0&lfY2yeGt>_k6rF*Cv>DU*}uNopEtzj$%-8a>d&xITK2+% zs>^U~e3LENZsfo--Tr3VA3jFUkzZ)p*4X-;W7Wsf6)XvG;yvKDZ1gY(-keod!m})p z%3UD)b~0GG0XRo)o3Z%`nQAkb-E^*>LJ~t+2iiKgBiq&Vgk_rqbJ-_C4F(_Cn`NWQ z3*3#xDz@}9=Qdbd8un?33DU=DQ%o!eFO=2-9Xx>Fob$f7S1?0m?B2J-6J?X0f*HLg zKb`=8yfil-MPmqgU}BGFao0{|()p`ZZC-v3%+f5|A6wcu_xEOOFbjcrEk)?!-os+= zIcmL3h_hGHWjSx>?M+30;gQ_9fx0ndD7JZV!$z$;>R(g)G=x56{VE(H3wvPpbQ~0^Jn9*H5ao_%q`b zZHet?6b#l~1_iBb!d+aI6$C?A)E*G-W-H~(=8+)U*I4x?M3|d#+D_3!Bnbse5|4es zy~59$L<^<&n%D|MLcSwt#o+ADdv?+W>97ROwz|va%%O&jR zY11G3J@_#htBvJ5Uul`?#AVr~4c7eH#N38>b~eXmVUmu7oGEn%D6>~cwkw8(bpvu@ z@eHZk#OpM8Y*As@?eqLnlLb2&YIfFmWZT`}wo`6quLK*HUU#(vF>(^-Tb$*RL zpJCO!1#Tl26)LxVTED>A7hd2?Rm|@I-tKPwIC2|iUyKrqBT~lw$^@ufx&cJvM~hR>;$-0(+D3PF(RxE|J+*AA-Ye>=T9zrZrW%D6Q{f zr=@uxm$>KM%_m;ZZ|uJc+=5zJCub?hWsS!Elu*BMr7U=G8EgT!4Bt1)wANwGB-oS< zF)!Uh2J_79x`rg*mR8ti2T<@Lg-wBGk^m<^83ad+z+AuM7!F&Ai&#afa+Y08H%gQ?)d2$ zcTElfaWaAvn((-rtlgc(JUubC>-avow2{ib4FhoE?7e4HQ{C1mj0&QlARwS1Ei~y6 zdY2}>2%+~9AXMqnv49j2LyuCVlhC_#R1gSFdJ}?5uL4p+{dRbsbIx<_`=0xa^NxGR z{c{+a?5sUA*P4B)IrL_H{NDL<0KXs%gze3U2a&_^l z!iz6wz3r+K)W7Fyl2J2S^E)MtcLM#eBIGY(E7sCgKE3b!wR{i)2)&pF=Ye$eTfk&_4{^uxEUK+9I~Ct>dBNcSp8XucQR+X_fzD85Ux zMA+t=gQk#aw+CxUr#kGmjjnbQ%x<927QdfIaU-WpzlRR%dAuQ}ZKh+xA5T5qGNrI# z*su^^M^qHATVmKdf4G*rZHRuMrH~M0w(U^j`iN&I=s>J)=YZ9$k?Y%P+!uXN{`zaa z_3~0PDNF6c4{waRB#2kmov1#4UnDl#l?&qzal2a(!M+r003ojT;&x3jD`|<*ddfHe zV^DW*D9&!%tJ^c=QfZd(TTe8;33G)^(oU6eF^wF!^6?)N^Kb5N%J904wxxx4 z<~US6@r$Vp%;cEZqA9c6=L^c4e0=$hqjX4B?JtYu%Im=i#s(*`Yb4gKRLgdx-PInc zu1$@nWheJ2zU;P9PgJZ{?9ALzZt~-LPO4_@eKlWa^TT%P?@NQ9pitr`k1vJ1@4KBB za)NiSF_h42MS4H*nEx{22NPGrpHU-W)-?JQ$^vF(H-{fH@I9V&aa)HoP}=gizNz*| zEW7^wh%TJ&l$CeXoi-iAIN(Hi{LtzB4aqa5IRSip`Etyon$6HzCKADn8kzeJKS9&T zvAN0X`9UeJ3!4sCf^PLhFci^e8ZxC~bap82S$s|FpOAh1&Dnaw^u!-XSC#~RIR|7c zdOTb!NT1}Tz1F$CNt~ZIMb9vqMgG3_K```Xn5*RX$*vs*rejKieE8}9s%h}c{=%ul z>+C|Q@iTAnS0$fYXO^bA#l{`nl7U3lQhil^qUJsG9zMR`Z2Y_SSTx+Rez|(^M_!p} zNMrT%gZq=xZD2udQ{!LHzV8S!iWCj(7uDp%A=?e!nv7jbzVx_RNwhr=xw+ijT5US)Kp;F?{C$&s$zq_qcj~7l-@{vvzr-o`bqs`O zy*PC%!|cd)m&^;^nWr#bz$@w<2%aoW6pk>ODsC{oDUrRD;#-}leAkZW%f}m)Rtc`n zQBmNkk#E1ti>xkD__~DL*rd&&Es{03^o?4lBQ3e=Xoas{v*J{r!%XU6Y3JAD4jGag zcNnf_Ok?jhPoP$JoBK3Au8z}ds|)mweHn}p?f=}sAXyuDMp;Ly6yXamV0TPbuBnTd z5u2}w;bQ}LZXumRH%f!F!|7(cj(7Y*U0ElCH!4A=N6kG$_zG;v{2enxG^9TcCi|_o z_=(3JergViso<&sPj-+L0t(k#k}8Qy$cTrvoA-aVDkR2fxV2)jE- zcF1b**)QUDfRISE&95`GAX!iA`&BIFIH%Q&S8MG+w@>%8#A6eWE~^AHhW363!}c z<{D_wjJ)F`abJ}vZCm`Y=vR-Pdd)sLIzySFy0lwQeczHmMKeM*ehdA~cL`xXIuNY< zu!xV=-;%-%H}Im~A-tvuUsF%YcIBSnBM*|X zTV!FGckA6+KZU7SSw07TqVzJ{0r^gaR{E3MjQzchk7*Asl^xSxN^Fr`{Y*cz{adp2 z(~F#~pbX&Z}F^X@_A`fXcubgD$Nd#!Fm z_>8QJp;M1W^)!Vq%V!A(E8^amuM<<2w~~TRP@kH)(O(QRxxK0yzE@h?yW9=+;xgza zNn>JW&-n1u;w_eG)$y>NK{&nORkwwwecQb{DB@`mCY^Yam&%&t-B3M=FRN(Q55;Tv zJ&i<1rPBg+cAp2$i-r2_75ozTZ!Qz^hRmb}nMycKXE+jKU8sEoIqdDdM%lsOm1&b|Iouk$6gf1t=bWcvC;7{+vM z;N%bz#em%mvA+xU?7p9Kvu-NzN9iSpaWZ4?w847(spRh)Q;R_+{1V(^`?hY5aRO&f zbptbw*IvlDR`{6s*J_uxxpWtf>giaRMlEK_>v>VHq?H~&9&RJ)_(u=>?*NcPsFKT4a-lB zIM;^EX15U6OExx%l@mILRZ;n_d6liPo-3(2W?ZETFFhL`-Oij3)zOVKh00^bsb8J!dV#0q4k2*ox`TnEbdpL^RrZK#lgRaHR(T$ z#l;+H(k8!Ao-X)Vo;_1`HW6LA!Kd9+pj@qmKWilO`t|ZeQ*u^DEyZOwP)^80CMJ3j zIlh+7z6M!&B~KB}&@~ z5qSY|hslRLraBzx9ub1y>XT1S=9RH7?x?qBl0OH%A|NNp1Fc>HvY0t}UF77UkG`TXEshvjgz zE+>h>t(7-f62`YEJrX&oKFY(ms#mQ%SEz+xD!OL(2*#g1XNb`!q;@c;Gb51ub)|js zqw1iN+KHvEBiYZ79}F}hks>~wSrckET&k15$s{G_1Q)N<8wJ(h&Rv>U?{p|CW zjHUbqi|#F^oYzFC@>@Cj%pHnv_kYr#k#%N*QZ!15?ub+AJSXbjet!OO%dPLnNbbAa z(O0DTYEK1-es5kbiEs^NnD$-6|0R3H(4^DS`EpfeuBe2`?`wA^uJV>jzHK5j+r;~< z-C(EkdcJ_;c1+vx-C#ZXJ52=7oZZ|vg41O1j8~noSH;Bezo;cPZ*Fh4Y|frZ4{vS} z#$s-{8f2uY!>Hiy31t-G72@URQF;RN1%qUW7^OVz>?L#+ zAO48~_#_Q-^!9!%!N=$4=f~?O$m{Ouz$YLsF3!gf<^zLy00ZRICp>Om%s3Q( z;828m*?Phrd&At_7;!kQZQOmlr9mLzKI7lU=lWPv^Y7^0y#C|@zz@DB){prFc=`EU zUHSg{4KHscUjWIU1Nv{j;ROLs1LM<$db#^}+Cr6lp>E#He?_6Js;TpL3^{vGbIkEhE8jGZkX)CKAaAoT*qC-6`3-Z1-rFzcVjhP!h?&R+)tboY1s z{{;Ov+An|sC{0ZXMR!{tT&Jpv(jeS;CG6a7VRjN1mrxt1jj)Iin8(IifS*Um##)3& zOh8D8$5v2OgkM}xnBP{w_AjVZ-MqZ5-E5&aQ~+{b7=XvtPE-&oYHP~_7PSXZ2mn_$ zf;RR%A|kdzU;!apQ6T}rzo5|egaKM0tRJg z?QN}S?F|Kb;|B{#@C!+R1t0=o39z_?fB+XiSc3mA@a}dnd;kAGXq@>lO8p^p6_^*$ zzyC$kA2y{2_4wn{A0J&{7skZMcwrV2*0z6;;AQO#wYwN6fa{N2wvN_r4p6{<{Hd^i zYlrR8`Tp(-|Ku0W>HJ^(`%@187kdCu|EH6Gi@*P2*MHdcZ*kz?0{)M7 z{fAxu76<+<;QwgX|1owE{bMo(bptXWKVYgf;QL7&m}XtIQCC*Piy=!id-T(-i)W5iQcl!H8(T5k?am1epc>qFKKh-oto5!@wUq zw@@fZ;z)d>#L)Zc#LLp*ulJwvJGUcx^q(5QK3?s&aaqy3d)ye>?yS5{7xxNXj7FWD zj-mARB?bK+K781I)=_tGRvR689T*;-2AefC?tMM>ZX=%6p4kp1U+T#e?fK?{+~gJB zCtv1|WP;Y5pI5p!^^j_oZiNPI$`U{i8g~ygO1H{n&KKXWxA>jycki9{EuAyoZ#*#P zO*g}^%lawk>}&dkj?EvPoeY;P;$ITGd@JiR(9eTHTyM8Haj!3MCpF_;H2?MbuONTD z{x9HGvX96Fe6IjF+PoumE&=b1zil@ixqArD z{l?w&EvfpJfzY$vASU%i_174$9p`iGzBU20fH&y-{89hx3Ap7}*p;xqAPW00`2R~^ ze}Mea@4o^+j*5<~pv4U@U*RwG{DsUgP5Uprct+Bs4ZqOcWv5^J#;-#CT90Sg#}8Jt zLnZDXN4OtG0Q_FCJcH`&hY?Cyc?L6_{dx(A=xotF!wi#oI+;lTO)>NAo zeW!;n(+smWZpn}syu>OiSl?3j?NBf6F&-fv+5aktzl`L6CaZl4N-|qf9EBP${{{cv z^}aI4D-WRe{+^Uzd7SmG>?T?(LrT29#cQb_kbzeETQkgLmBaJOjg5`&y^ZyCm!ROd z)_`zX}r3k?A=7VtB&=%?aJXtYpP3u9nB`KPIe_9sozdxplIW3Z#G;CR0 z8O1bM1&1CNjuS%tux-O^p|bC{?$&|f~+!%gXpA11n+9@0> zY8HQcz%xYo#4;YXws%~efYXC8VX|6|jWeAQM}%!)JlR%VVlX&yM3pCWf`TiQ;ccDm zm5=f`>lINhO%8v@Xh3*34~4D?WkB*7oc&CeMKzF0Qsazyg8Q2aa+LxZ9HpfiT9*l9 z3Ni;9-FRCWVW)&oi~|Tm>ate0=$#056Xuadng6cHxR&@3WPG75>&C_L@Bzul4UQZL zah6BfYK%P(#SV@VmqJKM4vU?7=|J_FF{>hOB=4C_2QInn#YLv%NNKWpk6=g z+7Mr%)@f)NwWaXkK==hX3s zSqIuVV&#A)ygUEO3B0?37`n9ol+gUi!u)v1@*?0P6WF!2O1Hk%d&x~A^$OU={r1-< z-@60`26_fdN=njNVt(?4OwJ$8?$1)YonZIBdbI+&uqBIS`1ENlQ!Ln)_k5;&J>|Ub z_fg2Yb|G+%dE4)!vpx5Sr7iVVha>E9wy0q!#f7_^VEz}T^+)r+>6*A-{7;+`yLLvJ z8K&NA=~<;-fff)O)+ejvCinOE=Z}1SeMMSYIxSBsyZ4$mn)!0AkJqc%TYW>u4a37T z&$m}-y_PJAqFc}*zMejzMY4AjgJYWQJ%dA012@q0&aDFVEtuf~e5kC8JHiY@yC?a) zGP6<^@CpOVw$CapoA=@XZ^%q7ReAIdM{pa>`wr53x^M?vB)gZUh<(#}?LrlzKm;!t z8gOCw4abFJBa!t!pmST^0b+*Hl{?x#ADAwbY{xnCeD7agZdGBEwYdhg*|Y(;sT6%uOti;QX-?T~g27NvX~Z^AxvKX4=1L$T{d!AAEA4A@t_ zJK{LO;TQJ!-bj^6@64t%YODwSNA%>0Qj>b5)^r~H(KA`OUA0$7#nR`B;PneLr3 z$1WZemXfV&Mb9d65*2_WqFfLvPMm^0DOnsjBX)I%fd?Mr1bfY6v!d84 zX$1zV#PnLhgtbN!zUjjw3y(Dh0Bb$9)Kwgr6I`Q0{(IzsoIL|BAa5+-9$)1$sZaIF zCON3oec2H#7r%(Ksf-3Dr4igd_THA|7YSP!$Q*kgzjM3r$Zzb<3%6MB>lX}d!ynukW;whvdg($|REQDV z9F*Kj@8%VpE;xRpD!5&!@$Skn&yLhwDj=CKDy<)ar)XZ8hGP+GrEGvqy#1^HBKHxw zo1Ag!e{6XlwwI>q+=6TEC>*BywvJHmHOd;Zqh$&gs_NBHlOeOm!uA2?9_Bh2=Z)Y5 z*=fPw)^d|DNgyRF+N+E$+oG&H8=ODN2>fV^YK_8K$Bj7?awret@`d|)IFww#>D9n) zT8_A2xN^LrL4sXE^>n50#MPF_I?XBiKzh?74@`-2a?(!TnQ)nTqdUi1+UXR0ixPT!@LYq)I%U>j`!73~oJpW=Vq1 zII5DBsc*47?zSXCha47|?!n*~0m=$Q)VnCVPL0J*CE#CwCV&0uhwcq_jee;kAGzRz zHug%8(Z`+Jq@p^XO07`^GZ|{E8UiZa;2us(U5+0X-V8y zX27TMTVzLYD|CuF)vgcLA${DcSV8fTVjJ+HePsc%(Gx#xP{X+ax0-E(wwdMctiEA*79(~C2krbEc895a z-+gi?@Zg&JnMiY3*7hI86$e0pr~pEySn_S|Li=nEA>gc)L> zrms=nezlVWs_rIUX$v11uFTObtTg8Jw*8{Vq<`#aKs@nAb>JWtCnve^Yc7l|dcN?a zfg)!8vD=)MwaH8n=2*5{s45K0pE-V98~oB2JrqzK>ACD*v9smTUPAW<}quE zM#u){WH(lBQekWR6<}BA$-v|j<9*-&q_qRGr*Ge{pB?yr14;rrQFVmS|9t{jSZ1CX zuyQlH;~7syP;g^z7o$Zk#o=z<3ry$p%yUN%XvB84ikuFwSaF~5&eY_{`93!E-pE0c z>_Jy|=E2X3Bdw)9tYB`hsUAN@#MvbW8A$;jkUE%=3+}}1Y_(IC`GiQ@iu}6X%5Xav z(QLP~bgCTep|fuihyna(7AY}WYZ}qLXI_#*04=L~$2NZ8-F*Lkpsh%A3xn3@qmUKL zS-|Nsw0{2lyfWo{00ZQi#Al;^xXj??GhT$6JfiY7tMy`4Kz(xYlVAfi)uF`OcbVvS zS<4pc-U;c69)cE#ll|l8dvs~p`vUOxae>Dw7K%FBSc+3?%Jlp=m(ir*WABkr+@-W| z8BzK0b^)L1k(6<1e($vN%~}>TH8uqM-DuZHk_nAx$?Cp z@M~>tZ(fh-5J7v_L!wk7I4h3DR^9TWDvQSG#Ic#6Q4I81e=fV%2U%ZEkj_;6{iL%< zT|gAo_X^Ocme!F;#ib&|0MZd0TIk(Z}_s#+LE4mV}*J$ys{!3#2;A zevD5vA7tOxskwG!>zgaRcFiOu_ky)w`Si!$&Nw9534hV@SMU1W7vQ|~c83*}h|1k- zjA^;1&m9NZ_6Sf?fpdtR9LU|v1Uv#>Ak!Z;z`r!D z>E9Ux@60gAvU|jGlc%lgF9E}Xhn{H50Y3@()d+mRxSyrJU#Dkh5UX!7?LSr0@$HnH z_3#X?oAI5_k~~X3^>01tX$|rWKL15}e(PVQzB`Td%x-KyY8AgFtJbo{yCUoa;n?J^ zpdLF>O2mN1B62>IoedEkv{=7Ivf8+{8G|wohHVQ9!Vwe*ah{NvTrCzKP9&E>lLu() za3=*Hc%oDfUw|M?ROL$hf6|hhR5Gy(0@1wK7hdJU&SUX;3 zIODhoWY02LXO6oCbE$i-ra<5FvA7JSzeN2`P;6qLP}TJEsQjR@@*v~6=iPS^8kC@g zo3x`CU^hV!L>Vc|BBXqS()eveDLj(d=0P_RLz{UHe<+(3wwijFs{yM9t5orOf7AP*CI`}@qPkXLlJ-MFP`md9>|O~*<*wT}MJe~riZ?LKU^njTN)$#1d0Izeuvwy!_t=K0+GV zp=Rh{%);0IBqxSlIM%IMW!}k7xbLVqRou}e)=Rg$)7eKrdsXP>S+UG+ww?f-hFR^; zVL^%&z%I{T{T{WpP`kndEh$*r3UZotX*uynWIp_uAWKV^BAPQW|E+rT`SI_R~3a5GdG*aUdPQJ%6$Yp$jZYZjs zDQ`%l78W(SawmY?qu;jbFjtZ@{0|_)4Xx*2vY1!PKbg^p7x(s%>Gxh1;=2-vSh3=ok zB|E;nFO2S4@n%l;-6o7JS}^WY5<17c6HcX^>|dJVbI@x%yeO`ViCuk|?VPDY`LnsQ|c*X1oc{Eb+tn&EVk_=!$?d&pSi8JSC z2SBx2S!M_Re!a4X7w|R+L5F95tp#HO_ei59-Qwve5DcOShJny6dWuPD`^v!H`IF?X z4O6xy2hfrOTVqrgR&hRA9dmo+V7LGHHFw(0iBv?cKGjtLvU<+zak0+d5R2J;#6hz~ z!o^!a-J|K8#5Ndn9#I60-ZI1Y=HfG4^5+;m|H$Md5j0{k=5C#{U70V+wE{0LWq$*@ z^!^#IEKoL8IOR_3a2MVNdq2!|n&`V+5#5|BC4o1L%Yw_@65$-%fJL4r2YJ}ZdJ0!g zwISJv6G2vZGPv2+m`>r;;QgBI?CP%Ri#3bKEXXn7DQS?9@l37debc0aOE|Ysp7G&v zZz7Rx+a+8qG`h2Ae}t_%YnZ5uB(o>H)dtMs!h|W25f6-q)2MuDHu(8x+-aXzbcVrB zPie_xaAZ8I?o`FvA{#8hS);SVY@bke0dwvbfsM)b5m}Yht)q}=iuG2N3mxx?M|Qci zJp8PF<(0}ulaCkZsfwgNgI1EIVmPIB&A&TOH zfieo^iz#n`_lA~d!$=#mv)GuU{zqiFM-)_8(OHqU!)BBv0XhZo_U)(^LgkMo^ zVF|)j+Hp6S!MW-ov<(HxppOeOqm*N$xJ>dDOjQ3ZkC!sBtBK!r8m3n@yBKK6WT)YU zBD7PD#Osu6yfY7dYPC@_n!jN2`lJ{XZx*;d z6lYUc;*q5Ye>XN8B&BZBxo=dYdPzK2!I;WXeX((f$_PD+Q+P{BkT`C{-d&J^JDhb% zF-hu5l?YW4u3SzeGX%S3Qk*Q1Oq9$eABg(gMd6$JzK0ags_(HNMG93bG13$EDA|Zn zU#nZG#&;*Tr^qtpzH|B1&r4f?hX-6Dj)wncnR3F;o;u^nuTOjp*cgTzXf5fvMt1l1 zNz!v)APulQ-@~N=%CarDdv|Q;L|+MK6GJi*&0njje-fg$Sx@X1iS939cO%0mzic- zbkO&BQ9_(rCdh7$228e$8TKcx_BGCH`ZYQ+)NaxE)0YBXA8nVR z0S(uHz6?5l70-dptlrWaDe2r`vloh6L{#cjcBQ@sJj{bQvyO1IU546r!g=$%)L!8f zq(A&6I)#JXf6_Xc0}j9Yaqm}9Mg^GiT4FWG05^STvng>)9vejZb5@$3B!ZJ*chf7K z=wuVjP$Z{rcR2KFLoGW$mC+^4NO9_sAzi%B;lkvA-akldY857x^)6jVS=7~!OF`%8 zHHK>>{mfH~0*ikeL_V4c0-nIaX~&sNAjzg>E2CVXQFG>=a^cyC=g50HRRE>(x6Su$ z=548*aXSyaA3Xd;+9MAPJ&hCn@?=kC5I6xP5jpXJgW}N$uJ#*dKs+NF!AaRYWb@u% zJZB(AgD$)fV#<4!THZ8IV={7sE2C+7q7Vtrt39~1g`@1A|IySh&u!b#rV+EXr^|UN z^#;K&eQu22L70qAzxIE}`OJo={BL^!Oywn|Mp++Txh(WB|I-zvy9&6v_yY*4;foFo ztEY&Bv`2NDt!_38*!Z%ndn!HuIt@n-&iIU3Tb8&<)Oc)RSoQjzuBcrUuET2YDbmg- zJBn|026eAG9?UQuAI3CU$=ac`!>TC}m8q{(Ct}{+xhTE2J+)pvRhda&%AKr9xgE+r zyEbN=?=nbTtd>6oviq43wI7`&d)6Jm;!1`fx4U3Oi?3gK9yhZd!bE61(fQQkU_i>` zhC!+`XEMAgTF1EchOe4+QO1#SU|wnZ2SHA~SMMZ*%EiEVZ7uIcK5d-My^@jSw0;$= z_6=Gd6jxH&i%s&m z6OrwTV%_;`{fN-tl`i=h=@v5sRz=5mP>C8SsOP_PBl>&wULhE;>30T} zh)qVa3dMF^iaJ)$VTQDu8Ao61LNmYlew(kgWvlB`bW_)KQ;#NyC)|8J^Lh53l9sxmU4jldz1&7-Ml^$8cND?IGq|EmjZR^CvK34W*D@yriV7fqfeeJFH<% z>w6nbR8hji{483mJ|OK@JtGY1Ia=QWjUQ{Twe_QBKq|JrxJai0pn0Ecjf}MHTV{Xe ztJF8aZzhMXAZRprT8=iNx*@tumGJ}JGB_O29UJFKQmQ{98^>|Q#9VRMi^OB}B1XyvnGZLwBl-z@+2&9h2V zmGQOR-$XwzbwSF{(^PDxZXtzwdPcrWmrLDAB*80>_@VD}Fc~0nB%zzTZ<>#;D{DB? zD5}s+f+T^Vv)Nq~B9#KkYJv0@#r@>Y2@y&6?P);lnS^<@4@!V{t+^ynmYpqIOBx<8!8tlL z3w~Sus!x_%Al)d%^CrCbR0@E`EXc; zrd+L9BdyfFb={BdqUw?c$fRxbXX9uzZ|jd|&0L_#OYXI$-GL-N?~WQLiLQ8ovQbL@ zZZ-We20UBNO0l@GD`sR}VTM9o8VxznhfD1+POlpIz6eJ2Eh!ZoHOTY?S)So}7^)y^ z>KM-A~xQdi zgyq>|GBgEQ$_Tu9qV2a@akU?;W3`^yocJQiWgRtfZyw+P>CLwNZZD41UAP%!F!D%C zLlR{p{P6wdOS)tN6vH-;8v>47pz^WzATe55E@hD}p9RIfU(1{h+Q3Edz~@rHT=l^-=9T{_dA~)xr`{6X87upj~&qX`NC%m^$S5ewkyav zfA=o8w|<@7-ZdzzT&PU*SGA4)u4|{y^8&vtIknru@fyy`%0!@s-$#Y;Q4n;M0U3KPZQ4( zBPOjeuAC`^YUl&d$sKIMEZ3C16SN<;!hI@|iUmzW4}xFaXV&P2TX1R#5$ZtMex1Qre|)!Kkq zC_8B7L8Q}q=hsUGLy-?Q@_P6@ZstXfjXu^Hwop=|T6Vg}Y_?!jm}|r;Ua{EQl&=G$ zf3&``!-a|QImbz_&!&}DN{_6{thlL5dGs;0d1(J?c&J|Y`PNhjkI8nH+|Lkq6L-Y| zVPDQj6XQ_2r+7TSPEY|Gr2_#h{I?392FFX>#78rT=4EK;KSK3VceugVqO}HRaBDMd z^pBQ=zm<+U8s7BJ(8_wH3k9Xy7NTKC8}xFq^J0Zx682m(eNJ9?sR|P1(tRQ)LnWJ~ z9t^y}_~vm%s+vmf$yH~iQ6GP;@zko{33Pl&S)`&b(nK1iby1v8F{)%)gYBjaF4R5f z$|C1*w`!om7VZd0E=K9gJeXPeb%!bGiD&P=Ls10Bo~xzZ7t^!Uh-@$;w<=W;`%X=b zo~(D!oSK~t#$92`8rvLFs1R!$edvOVVbAg872e=gU--R7>57G3u%ub_!rt5ZKEkbTM)crvBb#PEs|d zw6;{rAie6gBr{~{ICy@LbFbmd>0>-uy!s!B+I8#jEXC}F8?9eF;h&bJAosA8CToKTUVcwn*WH%KZ!mW_+qF5xh*hl27Q)N%W0$Y%EI?W_eDl8t| zF!c5}HVwF%kImx+EA;0YRvumbobqXiHS}iIkTpl_b^U77K0slw$Wz`;+dSEZEEM-j zs0lA)6bo<~RC60iR(Et(dbd>tiEdZW%Q$6#YYBgdi4Fz@9+Hy6vI9&Pl%D3h7T6-(^*D}>&6L37uD z*icSL4!B3)59slq*T-mk*RRI~o_*pASep*zz2A7U(*sQRfQ^)`J4b)psR87Aez|Lb z?acJRt|ie-5>I}tkLv}tKxu(7FnE?GsmPWD{#+*LKC$Wis|WL)N4 zUoP0N8Ow^@Rix3|p{;5*S-FljwkT*l=#UF;{Z(rTlNl&dW`>cTbY|?G%F>J+d|E4o zV?7dPBvaF5nLN*4;MT4$VvGQMS1@4)(IrLZ(V^A`6G+&K+dBI6zQx_YCxOO!09i+8 zez HF$hDgiFdIWH0dTB-&JPI$nddTXCpf1#GCg7=OMV-L&vK^ycdEYj&C1-6!Sy zs~<}euWvos-6AZjKg47Zt-<+)6*bdke>QIs4aBL_SIqQUkJgY_&WlTmD)!eMpS1tp z-Jp<-!=;)x`$z3a7~AaMbD^B?j=zzAy^0w-YGu{qv_XyzjesOG+#%yXJrG0vQfj<4 zj6Z$F^JashI77_@dE{NrYgh+~vb?8)%zv!b>`J6$c$5U`^ar+##$b4fU`v`0Czh3g<$fazbKzW405M-{v?x9+HF|6bYKaMIP~7by6VS*sM!iOgfgaHr)T zb?d~;c=ucpG^lAR%xksek+)=p5f7q_bQOzrx3*JtTvcyn5z#2g^2Jj;TC?Dp=re)y zaAjcPZ~BB=A=wQF2b_HrwKRw_W7syUgQ$PA^}BE<{E&j9=GAD|21a{k+gsmwms-Cr z*8Ngx_GSnSuHnk=z?jRk2H)-Q*|ycMB8VHzs_m8>uN-_?NS`JbTx2#>u&o#xA(r} zU1r%DLLAxbA@e9@M)PgGvzbU;RcBS26|FR5-=F%Q=6%kSE-%QkS&VJJOGC_Q# zFziWSK&UOwWDnDhR-D;7KayLM8gZSs-S~MY>KUhe-l^Z4MLMbC=$ns!=V;cdD865- z$n}@rrpCBlGYGt%%A568Ns$Ao)WbIrs$mwV(-&7WTV-2e<}-FHXY*PT!P>{9M;W>6 zKh%j~a|qN6=@^E41+gGFG^B&sdJk%g2eL&K5xjho+Z-Fd39)VEb<;@h#d z=^T@2@1N`BX{W5*mGUaIKZDt*I{cPmVf@pWT+!sPpM-OcDtcv#d)G(1B9rolmM<64 zh`U}lI1ZMONtxaWN6SCm$$=>07g-h-3!-)WtdZ;n;i+~rWT+z(V{XT^+nJ*YvF)^w zt#*mV5%hpww0`oU?n1nj#DY|oT05-~ueAJv6U@nP3k!7$NwGA1p+*ar;>jDNd?qrE zTGL+ghiFxubv$EN?E_~JmselYw|Nw`Qet5>hDlmBb&E`i!NVY&v~#CuPqv@SR}+|AhLQ|axZt| zW^d_H!PHM+vx4Ya@2eC#E;~*hW^L<4G;3c4q|{yKs22o(;u`tps%=)W;HP*$EDVCu z@bXt1Vd;jLk?F4{#8mcF#-p6_Ezhv%`}!Qu6hs@KG|zKiF^ZQo993_dt~u&yQ#&XW zHfh(i^D9vlh)#&>jZj4;kC`BdH zN2u3FL-y53n){p8cOosedK8I}x+^m>DP!g#yaI>iTZ=$?(D_;ZO)?w`cuO zZ=7z;mk0h;`wgWB-K7!rHJ7u7OtRl_OyFmE!cMZ?HUtP3qDFlTljet5Kh61sDY2p- z_IlG&^u6UaQRO1a)9mIvcZ<{?IIid6lm99FbwTs33Cq+N`<>31E{&;smbZJ?he2w2 zd*_22>a>?Ck0c68PT&hq?(@CWGYmfaeYPsxf#;pHNatX~$-B~@m)Pg2+M^5i$NFs} zs&uJn{aUVAx(gdMMM9t!DVB?|2+s@+#0_7pa4srZ5k?31BxeyM5NjYqRWmcFuYrsf zv{ybnug(>JlI}>^R(^xPHqkrno-jyUJ<`B^6ze9`+EeCWkm0n3)$L#9YDe7xTPORGu^AuS zigvM&ccpA?ULKJm>mFg*wQtflj|_fkCSFyRi1a@VWd<*-Hkm@vk&eN;kxwY$yt2TW z*hhP%!djE>Auu)lTSGOQz*EG6!NS@4k(3Yat5@)fz?8xQ@Ez~lP;Pum$%xc!EYdaw zwle)TPbMptyOnq6T2gmVvU1@fa(p3WR#6lm!)Z`ZbkX_7n4hhLo(f0jT6@u8Go2BYw&D z-I}`UJ5?>r}c)tXP-U;?(a2Z1Gg@R;nlX`XicWtC@^jjD+n_ zOIJbRduzzU34&?8T=>b zzwd1MA0XbZk9@9UAI)Q{^!lu&6EeAwGJ4MaA>E<>#q@zIX5TfTwcW4jC!O3RMOl!I zl(-#6BkxB=T@%*t`OA!>Q0Y43uLuut(8>7h9eO?tRS>G;kfA@hi*_C{mU% zga8W_6UXL)->tesPiK|Oi0A`$v@Lnu?0?w%qo2Fj|ES%WtT28HthlI(^msKuEn4!{ z7>;A)f-#3Z=e%YkQajD7oN>ICx#8HovsI_`KVXxNfUX#!DfGe&et(B&66gf1Y%f z^;?VkDW(kVuvg=$-Pi0*8Wq*6Vb_D~1;cF-T@@M&tut6-U?9H~s6~_0Vcc)N^{eXh zJ~7MH`mnA2X$`ZVHw~OZD=7&FQgimq)|VA6%HNjQfu-C{?GvfR%2IhBnZ6W(u3YiH z5514#9W%c23MN35Dp_Vh19}OH`npRc1xc`^yJD(4!X>??!DfN^3nDv%+}8Bjd3#H% zA-cJay>DR>Am(3{OS&YQgmFCVBUIexLFY=c>VY$z0-45!AKXcvJ#Bi#+eZLQ<6V-M zLeTbDFiRc;s+vL8gpQmcQ;?A*rU*r4YQri%D=oqXym%6`vyRMk-IZIvn(D6~y>2yN z`-O6I4c>%zdJB=-7hsL`CO~#kN(6&VboOM(RdlDgwwFIz3c;DVR*h)Y7jE5OJa#SNSYC&-i&Y@_<*+i|~^j zIqX5M3Lr67bO4SCWiu%D#T~tc^K-Y|s+`)#I zx~P4DJjo8E8t*{cuY{s1D!r=0>>Q>kot0j9~J%x28 zBG&SW-zy#0(X|W$zp4(*qU4lLzMZzpG#C|lm_Z83jz8O~i$~gGZ$`db04L@7W4}?L zG(&PZ1d)~&K~h@j29a)I=#*|y8c78O zhL9LS1nC&MyCfwgM?e@F$)RS5A@1S(-ut`n`?#V)@-fKP2b0$O$ zB;QP6Qu(T!&ws+_cHriXVj$8b-@cHmk9p;i<-_}VzAgR87P|GW*2L?+xK^QhhSZKe z3zK)>*~%xf^Z+gkY!%62Z}c~!iiHOl^m2L?rdcXy(IipPEDEQbDr@$8ZeJ_eZFiy| zUs)<5^;wz5jCc*l5UARhIS*0<(mYt}jCO75z4e+uxfV+kp!vDWLR?N+*+7e=B`br8 z5|pWhjC9D~yoqaXqY@kB>u(Rpp>eYlg2$vV4olM*;-k# z>4gMK-#{bvnKJLVz&RjEJfAK0DcC;QzB z7iw-Ill$q8DlTiSCymL+zE*BK{AtX1%=w2Y?iWB9khLH1QyL-nOjVVeKPX_4Luz8sf9fGB2@o|y;;*f}z<$gTvJaDCT z+w||QRPdagwLi^nM|G6j_gFH{&M_cIx5=}#XFM+C`uH8;+k;E#>AJc4E#r_3UY}Rk z7&+QTYK5js)+=DW(>NoAN%>wQ>9L^_Whkf0TPg^Pw-@xASlVra+tX)Sej#CcyQH}t z1WU8B%vF~1y{-ybjh}hBd|j3+MA;02oJ%sRW~~~@5XW?LtG4WcZ(Pg+dnh)`%^hX} zm_B7Gr+W|Tr5cu7d#S!>0x1||QA|8DkT0ysk5s4N7t+e$-vE$?ufCVs4(4{icminy zqC>762AT`!8IC5?RtyJ%15zf1niV;?55tFs_xRC*RyI@eTfSNw*(~ja(E%JgGFP z)l8?Q$sB4N4@ne4MDm!bw;nAj#7k=Be=|re-GC<6L>iXcdO?fg%fC&e7U(NLH~SDH zVD;t{b#HvVUNO3fXjD^OH@*k$sNd`Ms&>P}Vmt`D=`2~tZ^s;`yzt6)!?$7$d};m? zY;v}XHFe5V)+Wk%XF&w{FREwLN-O?mTz+6(+%lnvJ?@1XUp3){35|)^U0`zaf`WXt zV+s1Zq9BgU+OJiTxp3=?*m4zmIjbcpK7RGis%ka4iFpLp+Azx|@aPa?v>;H0FdT7O zQ~@hZTPm}|(+coa7j=w3w;V-V#awyLtbpAX5ha7f4CP{tb51}R^XhYFqE9nA6?GNE zZT*Z4{;eGo9L{I$@=VlvAZT(?U5xgObzx14I={bG|N17GJMotADTz`8uzNheiR!cP<_(YBWuIEj!*T>q~dqtlbp6P z01TWyJ18h|hE+dZM7btf`NGP!kI}o7SyyG8I%ARNBwV!}*SMv~{Y)XW!Nt@7J~#-w zN=rR-$DaZZ1F7neQ&~kXs&!ImlXkjh>phterkdM!ME+CliaC1HMIMvH@pEowP=O(< zLNb)37%1&X^!1C&7eSxtDdCBX%jglyjYoHH>n(AN+Am!4Z(J63nNSxvoR4FP&EyWu zMZOAf&~D)~qs47s#j=({h%tQ?43b+Nc5 zYpeB~8rrb2jRoVu_)7}S0aqZsUV`2rbjo_s6UNzO0`8APQA)*aFF>@8zv{jF_UEr$ zgmnrPVPGPpS2IE zE15tWr|oFn2AZoZ?xt48Fmw!eI$!5w$1W`v$?Ce`-%!(IRX!5%6REfJf(98p$#k5a ziV&?mAGP1op}%h2Z8e#)EmJdeQJeluZNE0;P)|70b^Xbcr(a>> zvB-T}QI_@wM7YY;ib^!i1%Vy(CZ2gIgr-b>(0IgglBb&~w=ueWa;y#!xa8*x%ZsIE zhIurRet)lC(Z75&$Sq2vYPs-qpI{$Gx**IJ@hy(p)86dfFRH&;&eH-l?>(Q^Fzuyc0klmz@<9+5p4>K)qotCtQ_EeO#ca;pc$2+_u( z;8x;02Z6q`GHBjC&Z--{nUVf_0%ktttwt;K^d+6*e(Ct?M`Q05jZ*A#p6U+el2nHQ z2J|dd4rktLJAL9fB(tspWG4!2cTeIvG~dZ#vw#(;-WjMu!^Z?MWcEa9_dBOE>b~;V z|7_O?aW}?E^!kHj9Nd~qovvk@sHNJLc@#L(4_7sWMbdLV-*>7SH15OxhzQTcQ|b~uG;pzF7at5oEBjLf#pLdR}{N?6-9zKCRwU0vZ@zlG;(Sjn5GZi zj53)12$f6ozw=uOkbFaDZ-+!J0eJFc-~FoGlSJLSB)ugu z3-I_Z;P?lf@$Xnw;j}rkn**anl}yav76-XpT!&N$vy9EH6&(LDN*8o}MyXli;v$Zim&;q(%b8yL~F43mib7_9YC$Rh6GYg{}AezNn7gH?a#Mt~-=C zgY9LACGfDnlhkcqs~9{ogOG3O9eA`3I(P1*cRMp&(igF$gB?k<-$m!KOTlJ#wp{WC7V-Nlt^?~~I$@Tbtor!c5@AK)K;l;_ z64#ILI@B+`33>d29JbRk0zpMw1JZ8waTYdGqYm`kJol>J(fSwvA$7x7Qt4&-9x{h^ zQVq^#ZOJM3vv3#pS3EV&Ha*H5Ko)-9 zn(3GLF*CCs1{WD8O#JmCZUog{s5v;?C0m=-{834?wovVwbNETbb9y>+b~ueNOdSd6G^E;b8zA@ zg^h}P$)P?NL*M5_*m9rS@kp9!m*H7G=3RlN#F^T>v9^6k(KQqfZ7+0A1;tX7YBUK* zJ5kx%_#p-R#r@ZcR^i|{@y}MS!yqbI|afMRt+uOoB8Vw%oJ*d%&gX3EhRcX-`pz5d?et-C3UVb>^w$ z0BW21+q*VK-M2=@^4~;dFp0E_$)x`m`o@$BWUTXMQ$!uH+vsnTW2utl_%_d`;IY830+<1<~!Gv2WaCX$0zZ%6}NH@3EjQqiCj>Vg9zTY zD?SGs4=ke3(w?PG7##509Zu{J& zoqpddE96fNZ?BFHr=38!v}0CqIvv|G-2TYh<}B<6=@w5 z2BuVx+IyFTnp>!L^FGu}`2Z>l0KV+y+<2>ie?`$M`%y4^VPaG6$V@y$Myq+Z=i}wg zu)SNF<8(56uQT}a(_s|-RKSo;(gqyPP=Xk3%yMNbm_C14gW^^aN*0)^8-^E03U9qgF#~G!M;S^$T z%{O}e6D-;h0v|7VFHyR=o(U|v6UWN}eDtd0sQ`2SE-bohErm?8zk^p^&fiHB!EZWO zsvACUpWA(QH=n=Px#tM*nW%2hKV|QIm@@#7e6tr8Fqmyf*i8QpvRoiWs4Ku>98zc3 zql=$PJ`vZvTLNwiCieU~f`3JydjHgqiS&4Z{1-Z!a;{&XcazWkw23P<>#~=1clrySPC!+el%$H zt{{_&zy6TP-kMgCeo1rx_rcDs0ux>}9wY!Ub@^w#nTC?NK5HQL+(vc+zp&WA~e zQFp%9x^C-AB-798Ek9P7e(^WoH+-$vBWTBurV$2G&SrZfZP#1n@rH`tibArq&AiU* zw-qDEpB}ib;K-R@o}&v56|U1Sj5tIzimy&o15kP14EKVzR#biJc{VucJUOV7Ic^&@ zI+w6TM65dq#*{*52p|kO&{n3h7KhZW?6reJbilUKg?#UHulz~FSA4Ws1VKE}lmU@k@~BJYXhZcGJA$4)MHud{8SztyupnRYx_M zcl%G3A?y6LseU_#VYT)J)d9cw28(I;6Y+!dD?Cth<&a?qT%1xa(d!|`NaDG|i@n6! z>{gzBNqV>KOB)^%K}fdqb2j~XS`%BrrZ5md>DympY=Fb$3v(9(nJHWAG%i0#_`E7o zpL>G3{*74a8lki73FmZHkmRpcgkkdw9rI2QOf@-0r$n&=X){x)Gzm_S0NDJbOsgV* zH}}LV?2}usrT#9B1cj*GN+R2P3z>t#$LtYbF4xGcC*ZwbZ(DmjuC!d2MdSFx(&df%8EYEIWB)fSf2qTVuUT?nzVFTI4f$bM(71i`XV204sJ)RAQqt-NqF zhkT|j^0&$}iFiS1CdD?4%c4T}@vu4ZeeR>E%a*7b8?>K`RzOJ7U(wdswiBmJT=40b z(Ri>3O_m?i^_d<FsiH7?cBruor{)ObsJYDd}LG56g!oI|P^t(Z$ zD|ZaTTy5L(BiemQ&~pvw)xd}v>o4!o;lwcIt`ELwO?1TpxRFeF^;+mya-gr3OeaL$ z=(~D31VARZ$xP1#hTB4~-&g}PUwiYMC%>lIq&-%sTaJ^(?*)E^mhcJKXn^rMB`Qmc zg>|N%m!JB_AI?%W`_1=q?Z{1?fy0<)?Z41{nyMmLoPC|G|E}?EldaQY%&*HEwgt|v zZhQ#5eQUmxc)}&Gp0adR4hF*!P8Q*0(-QVjY8`Rj%DwkRt$^u5?^cMu=rkaHc&$jJ`cSZ72nvp34{Rgc8dlm2t$8Kj$rBFx!UeTRCP1h4;KtByQ?wA(;fsk=|UMq2P zT`O->O`~Yh1}p6WuqppL;mll|{(W#zsCS_?`h=!!lWNNzN+oDV;4C>;VBu45PC4y+ z2X$@&lJp|MNBt2yhn;yvODl=XM+4WVx~27m!`ln{x2?x#S7T}+JkQWM&RNZeTiozX zSY?35;cwsT$@pkB1yiR))(c~>(N{iFK`r^sC3yN~`hmb`i1g)tB?0ir6`4+lm6Nh{ zhR*c@E*W@5wZN$Q67yMR-g=b;H7UR=n@541fs-A`$p{-P?j9i+~tC3(Pqbqw;mi;f2gF>V>&E{C|Mo2$>!7 z<^ib#00v~@*39}$BKYbYpn7y(qq6tZI#1OAu2TAVARC~O*N%{C?$8Q8PI@^93mk<3 z8xLy+wBhe3Qil*gZU=24S#&9p9*`hY_gg0m%Nn&ZcuJIsujcIyk04C@2#{Q+-$i{D z!g0zH#^F?J>x)Moey19`sNPZoDzHP(Z}~B_S$yiSf24jYx^{N)p2*IkLq$UfqM97>VI^-iNe}t z;;)}1zdEGfZTPzeRxA?yv%epa>TStP!VyaGU?$k~Z)(tJEDw>>j*8wuUvXP;eX6r; z;cO+Q@dnz6hC_QdxkqdYW6EKoYe{CIgV)uu)<`7YGKR^On`9iGbvQV!;IqH|M&fx}T zS*P}euhPr2ETICY^zO+1K1D|oB5OhUqCdIuBqh+YNL5H}Sz!7*Gqd2CCXUi6<~mzd zqR;9VXc5wchw1aM>k6rXHls6V>#ffLKlC@2lEjOWi3pi+LXlLQw{pJ@Hctwii1#X%?(`verBpW$1lEzrFS#;cLf&IFsJa z^@ML(X$0EBL`P3XgsRkLom<-O60@vXy9B7v;%872rk_+ih;lPzdTn?mTeDs1TBuN^ zc)*~x<0h^)qzv)KgXn!69|ddbH5Z~(3KLloY$7O$WjmW1`3qQ2h0E=XJi$H{P%xKU z+rAm;m?id2#`tVn+?!OA9dE(zC4j*l>KLzF&#Y@cA3nz0sZZ(U3~MCb*SAP)Drk&X zrEBx5cH%2|GzS;1N@~?%PbMun{+f|2Q?d04cCLd-6rt@1zh%ocHyGjU*Xe#r&d3pm ze{#bRaMOiJP0rz{qDP-uvt$%(CUB|Vs-&@>s=hzqdym}Ln2R0c!Xu-L2-)w*GLE;2 zNZ_RKCXg>aPsE%xD8_a3DebOu`s~*(VAyVhtm6&R*@)KfPi0T2_zU9E%}gI{f1w-u zR`;`ZVSkKTUXaY?*jP4rNJaGPJi%83L>e_{f$I2_W94T~Tt~#VLch z^4Sn~Za=q4dI+?2_n22YN%GR>mE49eakLj(sM+jMrU%PoxAdA65TW-)Y*X{;RGm=E zMRb5}>M&>#z|vZ2Vf>CSyi*9lXyU*HUhm-3|4D)Sl)ku)_}+R5?(nEIz_txoq(Cxd zmY4j{i%!Yysvp{j-u-ZCZiV=Im1ABO|KR@#aJU8r@ip!O;SZ}_@>%O}rL=LJSVFlv z5MFD9sOG+cM>aVf*%EDxSvgL1UDKkk=EkqyXv1$WR+aPwj*m@sXU{t?e6w)cM^l(>5$DcN61JdZ?x^gTjP5rwDE5_$qXTx$r4UpkoRGl%J?gafCa!YzDoxwMU#gW; z2kw4wKM=%3AsjcRk}}g#Iu`v z1-uJ#Z{OZAE>3Z@*F64`s*qUhHT1}ZrK4C>=xvm0%ItvZ*R&@6S$mmIP{xS>0e{Zt zPN|=X0Xb`bQRN;ybNP8zO2G|1ZnS5F_;_@$=p8Hjb zL{F>zE*Txv^?Ph$zt)i2z)`(2KvIf)bw6L8c|3~VWOm4THkD&>+**(Ih&wK6dLscU zNer3Qi4etn9Gv51Z|y_werze=VYMnRRl*s^Nby#aeW#;(hD#f(QY z%H7esmD{h3bKpfx6K;b7^r?}tlH+@YG5JI$aXmExralXnul=IwvX?L(#rMu6XeB{Qvf+n1qC4N@{p=b zLk|eyzpmX{skgv1q?#FPweun9fxl^ZdaVg3-#g1}aSbahujx5ZzI%3)0a=3jg;#4l zCAj%iOnQn1-!`pFpm=&>anUzcq0E3RlC_6IYm(#ABcntSTHcx)Ba;}bk)#09H6Pz- zh7u=X58(jqDsSZ(x$j1;1KJme1nRZoSp<>gAB_*HLJyx;RiOgD1P#0vE3MqyQOjh1 ztq=|Xoz&Vfcm5n&?B0LU50;V7Mcg2(?zOG}&WpQb)9zhFdl zywLKbr(}1=eTZUqAXT<8fs$#_ZeL0~9@zilB4SslnS2Z_t)$5OYO4T)o3ij6H$WDH z9A~9IMPqIQ3&F>)p}QTMW-K#loP_%W46<%gYr3E2V-z2~!K|)f9R$IHEt@|uGa4JK zfeGUpvnDx9p-`c+2660yP+&9&9P8`n6 z)Xv?P+xYhhf$nB->BYW;Gfi+$ew-)@8z?=!Pd2_T1G4|FzQ55A*9s@t{oFvrXm)u1 zq^xsoIlbBR+t4F?6LT9UeJ|wbgA&zEg(uKECJN9nY}=uvjQ)o$VTwOdhru`KxZs-y z@|?mcLkjD}vwNYCmA~suKW3;nG-}&2+-Lu8Cdn1%N2?c{SZTLV6@2v?z`Qfor7$!F zFLR0L)K(CY)LfxBTGx7DTc=R~LJDYfo(4uOfoo|ImFGz~6^f14PsR-vXY$R=4x`G{V9Qr35GgZ(GQ?9xMJf=zRL@ zeN?;iyCA+Q%!342h+9t`SP4mLzs%)0m0Sd8(>+UBfTRriIiH&odQCxd>gX z#}9*tu$@`aERY{JIbg}zr^>;+KHCq<&tB_9>2<2Vu%}yI24=rm!=`0R8&zhD z@Pm!vU6LpJq;)z_sIp$FIzB%RkdKRT_#>Q?`Aa!ZBeCgPW=W9kB^WQc&z76>H4q!D zjPdo6Pvi>$HI7gPo1u`AxWD%Lv_1D^mT(oEWGgOH0$+o{1`JVLeI*o-MB{u)voads z+~1bz^SwdZ!d?AwbMPSdDQ3{bvjp!e9)4;g&ih#g1FuTKmDR3zVt}KE3iO`g@Ye$r ziJejp=5@P-gXW6jNB^{JPoYq_Wbv8pkOQAV@LqlEnxKzMTzU{qlp<1fToz_A7oiM# z0Mt-I73jS1ThVx+{Ta>H;nw3&g#zV%{9nsHG2b9m4^5T+X}xq#+WeCzGeHvvJ9+!2 zVd@Iu4Z8XLae1`L%X1vs%w!>)fQ*P7PE{`IaB$d0C;?0|Geq{r&KhPL9h&aBVw}Bko)> z&$mVL89E~5vgapK3gHH)O>RG3yHleDcN_z9w5hk(3&2?)-b?X5Lvy0%fGlJAjg2422bTkSy1Pg$~zk!-aF7Z+DSQvUG| zPHg;j66}|M%6^JQ-#+IQZ&evlmBkao{($Y306{WZQB(i&PKv}kcq!#~c%X2YJ2L#H z&>o8RHt_8{$U3OF479YjxA46#yg3~SJUfFzUuI)rkN~SoYPE+?Sz0kMvcC~gV1&xz zU@!s`79PO7a`hSEHGJsX=F{RgcXlB2o!H!z&mtWOp8Iv=RnhckrYRxTwP1fWAmeR$ z!%~xh@xxM)eWXcmfITmS0iKFjIwX{|l@ayvJgTt>xm6MN8IRfm@3wny{B&{g_O5SQ z8XJoX*x>=S>#{dS@0vBW`5!hDQN*s*=wZZt{kLXd{i{{~-ZCtTU(5%$n4#iJ0k}?0 zyO)Pu_@P7;jOv(ppwQ5eE*-F+U(CFSdD{eQt_deuD4FQ!Mht= zwZSjw#IwdIQd?<7YO2fY%(mq@crY+JK3-liM6M?9OLzeRl0q+O)KbaJREAEiLUs0{Y9-y6(9FMVcv{S$w9_fl|BL zm_Hm)A_wq>A^XowwEWpS#9+F7U)y_xH}sN3$iXxlqYKc`2<3PI zD8l~F{R9jto6$Vv{_+p<>~nN#(3VKZ=zVy5W1#IpAoG9r|E|xYZA){D?E&`}SqDp>33 zMbg~wcA0C>x9uV~Xk}raoprT7B(G^Ow?(JPEvO^-_QI?qxbdnW@LKxDRTu@%7=j^2 zwN8-ei})`##+R@Q{NO(>rNCxxvSlchnain3oCzQe1qG~ zONvWUY+G&ZFRNM4Z%5n3ZRUD$4eBa?46-S$9>06lYIhh?F(54Noyq!wx4xUcacrx z7?Txr_O68wFTjTZIb6~`X8#A4@kDxR=Y3nhv8w*uCg5N=2-5#^WB>b(VqnaVxRTTE z%n~!moCp4*yCiC%T?t_~AL-Z3H;9I9s0NDCEvPQ^A%)kB^LCNu9FvtxrQ08SUZsDc zDwE#m_A@~xPr19sb_AEaH?uH@pAz1$%OcXtXzJ*w|2&v;KaGbT`pHx4Aq^GK^Ow-- zZdM|HZjF;Zl0`2f+3ei(sMTU&{|VjjGY?F|fUz91!mq7AgO+|aZMDZyae+qPB?xAw z%1y6g{Z;#{`o(FJtw_?eFDsCAt0{i-*w*_8;HBXu3Bt{6%6bg(nI`!8-Su(#G)Z<; zewS_^iO54``%dpEJN;@n{Zuk`3fdD{gnV+pHARgl%Rv#U!kZ-0v=arY_kMtOrpjr(^Xwl%S4p4r8ZlT1L;@p5Bbn$nZYC7c zqGcHWrc({F`AAgh*-po6jNu+va)*&euMs??L>~Zw1%0V4eaukV2yLMu)ag>Z6O9|n z=v+{YR5sgc>?w<||C(K@bH7C_4dSm+I48YS=;e1rusRloy6orw8Fm6Cd6C&9#te-l_Mm&5)`w_U;$ns4FG7lto*xJwh@w z_IhU~b~WHO@X%Bkm1MDGZi>hYxn3ZkmCgQe)SOHaYQ+EFqjw~gLuS+JSL_dsQOv3s zuVTZdY>ItcjFcE63IPJe`uL*X$X?Kep_%!>1B|d}AM8Rw^R#&a&?2~RY=ByhtPJpa z2b)mUS8{p?2ihltz`!jSnmU6+B_8Ml?k>o$J%e2&s`G2df6VQ#V7^?m)C!cm%<8cy z1s-6~VfMbu<>bqF;s>&@J*|s^u^Na61?N=Qd+Qf}H82^qt55ZvKIlHox%CGL(Ky)p z@<|p9JzR0KZyqybcPJo{i!sv;1!7ROm-v=8l2GfOrfOwImdTvE*1o>njB2r0nSRTw znUzP`+Bl)I3O!hQj~_vGf{I)0d_xM|ZTSSfKj=Mp|NZk~cg_RA+$qA^gkM*|95UaX z4EMy+ju%FYuJy%pI3rvxi7_aT&ulyz_%OQUZ-^74KOaiI-uh?pt)ieQUm<7t;lBXH CedDG8 literal 0 HcmV?d00001 From 5489ce10ffae0521a0c2dfb9d15bacfbbb04ffae Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 22 Apr 2024 14:44:26 +0200 Subject: [PATCH 069/141] FIX: in source code and general reorganization + cleaning --- .vscode/settings.json | 107 +++++++++ deps/boost | 2 +- deps/eigen | 2 +- deps/loguru | 1 + deps/open3d | 2 +- src/diffCheck.hh | 2 +- src/diffCheck/geometry/DFMesh.cc | 35 +-- src/diffCheck/geometry/DFMesh.hh | 22 +- src/diffCheck/geometry/DFPointCloud.cc | 19 ++ src/diffCheck/geometry/DFPointCloud.hh | 37 +++- .../registration/globalregistration.cc | 209 ------------------ .../registration/globalregistration.hh | 163 -------------- .../{registration => registrations}/.gitkeep | 0 .../registrations/DFGlobalRegistrations.cc | 110 +++++++++ .../registrations/DFGlobalRegistrations.hh | 96 ++++++++ .../transformation/DFTransformation.cc | 1 + .../transformation/DFTransformation.hh | 15 +- src/diffCheckApp.cc | 96 +++----- 18 files changed, 432 insertions(+), 487 deletions(-) create mode 100644 .vscode/settings.json create mode 160000 deps/loguru delete mode 100644 src/diffCheck/registration/globalregistration.cc delete mode 100644 src/diffCheck/registration/globalregistration.hh rename src/diffCheck/{registration => registrations}/.gitkeep (100%) create mode 100644 src/diffCheck/registrations/DFGlobalRegistrations.cc create mode 100644 src/diffCheck/registrations/DFGlobalRegistrations.hh diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..0aa6b7c9 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,107 @@ +{ + "files.associations": { + "memory": "cpp", + "algorithm": "cpp", + "any": "cpp", + "array": "cpp", + "atomic": "cpp", + "bit": "cpp", + "bitset": "cpp", + "cctype": "cpp", + "cfenv": "cpp", + "charconv": "cpp", + "chrono": "cpp", + "cinttypes": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "complex": "cpp", + "concepts": "cpp", + "condition_variable": "cpp", + "coroutine": "cpp", + "csetjmp": "cpp", + "csignal": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "exception": "cpp", + "execution": "cpp", + "filesystem": "cpp", + "format": "cpp", + "forward_list": "cpp", + "fstream": "cpp", + "functional": "cpp", + "future": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "iterator": "cpp", + "limits": "cpp", + "list": "cpp", + "locale": "cpp", + "map": "cpp", + "memory_resource": "cpp", + "mutex": "cpp", + "new": "cpp", + "numeric": "cpp", + "optional": "cpp", + "ostream": "cpp", + "queue": "cpp", + "random": "cpp", + "ranges": "cpp", + "ratio": "cpp", + "regex": "cpp", + "scoped_allocator": "cpp", + "set": "cpp", + "shared_mutex": "cpp", + "source_location": "cpp", + "span": "cpp", + "sstream": "cpp", + "stack": "cpp", + "stdexcept": "cpp", + "stop_token": "cpp", + "streambuf": "cpp", + "string": "cpp", + "strstream": "cpp", + "system_error": "cpp", + "thread": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeindex": "cpp", + "typeinfo": "cpp", + "unordered_map": "cpp", + "unordered_set": "cpp", + "utility": "cpp", + "valarray": "cpp", + "variant": "cpp", + "vector": "cpp", + "xfacet": "cpp", + "xhash": "cpp", + "xiosbase": "cpp", + "xlocale": "cpp", + "xlocbuf": "cpp", + "xlocinfo": "cpp", + "xlocmes": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xstddef": "cpp", + "xstring": "cpp", + "xtr1common": "cpp", + "xtree": "cpp", + "xutility": "cpp", + "*.ipp": "cpp" + } +} \ No newline at end of file diff --git a/deps/boost b/deps/boost index ac8c15b5..ee2a0a55 160000 --- a/deps/boost +++ b/deps/boost @@ -1 +1 @@ -Subproject commit ac8c15b524f752c839379d0ddcc1b4dded0998de +Subproject commit ee2a0a555b6fe33458ae19bfa1e193d8e67bb6e9 diff --git a/deps/eigen b/deps/eigen index 77833f93..2265242a 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 77833f932040b46e79b6fa6522594a6df27e8a76 +Subproject commit 2265242aa121742dd7e80a0167228b43e95bec62 diff --git a/deps/loguru b/deps/loguru new file mode 160000 index 00000000..4adaa185 --- /dev/null +++ b/deps/loguru @@ -0,0 +1 @@ +Subproject commit 4adaa185883e3c04da25913579c451d3c32cfac1 diff --git a/deps/open3d b/deps/open3d index 498699b8..7f83ddfc 160000 --- a/deps/open3d +++ b/deps/open3d @@ -1 +1 @@ -Subproject commit 498699b89b204c69bbb70a856fd2ee2882990795 +Subproject commit 7f83ddfcbbb512824f358c365a3c62f6cd246f87 diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 84fad487..c4fb6a0e 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -9,4 +9,4 @@ #include "diffCheck/IOManager.hh" #include "diffCheck/visualizer.hh" #include "diffCheck/transformation/DFTransformation.hh" -#include "diffCheck/registration/globalRegistration.hh" +#include "diffCheck/registrations/DFGlobalRegistrations.hh" diff --git a/src/diffCheck/geometry/DFMesh.cc b/src/diffCheck/geometry/DFMesh.cc index 1c2849a8..6cf59627 100644 --- a/src/diffCheck/geometry/DFMesh.cc +++ b/src/diffCheck/geometry/DFMesh.cc @@ -1,5 +1,4 @@ #include "diffCheck/geometry/DFMesh.hh" - #include "diffCheck/IOManager.hh" @@ -18,33 +17,6 @@ namespace diffCheck::geometry { this->Faces[i] = O3DTriangleMesh->triangles_[i]; } - - // if (O3DTriangleMesh->HasVertexNormals()) - // { - // this->NormalsVertex.resize(O3DTriangleMesh->vertex_normals_.size()); - // for (size_t i = 0; i < O3DTriangleMesh->vertex_normals_.size(); i++) - // { - // this->NormalsVertex[i] = O3DTriangleMesh->vertex_normals_[i]; - // } - // } - - // if (O3DTriangleMesh->HasTriangleNormals()) - // { - // 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]; - // } - // } - - // if (O3DTriangleMesh->HasVertexColors()) - // { - // this->ColorsVertex.resize(O3DTriangleMesh->vertex_colors_.size()); - // for (size_t i = 0; i < O3DTriangleMesh->vertex_colors_.size(); i++) - // { - // this->ColorsVertex[i] = O3DTriangleMesh->vertex_colors_[i]; - // } - // } } std::shared_ptr DFMesh::Cvt2O3DTriangleMesh() @@ -83,6 +55,13 @@ namespace diffCheck::geometry return O3DTriangleMesh; } + void DFMesh::ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation) + { + auto O3DTriangleMesh = this->Cvt2O3DTriangleMesh(); + O3DTriangleMesh->Transform(transformation.TransformationMatrix); + this->Cvt2DFMesh(O3DTriangleMesh); + } + 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 299a23f0..a4a860b8 100644 --- a/src/diffCheck/geometry/DFMesh.hh +++ b/src/diffCheck/geometry/DFMesh.hh @@ -3,6 +3,8 @@ #include #include +#include + namespace diffCheck::geometry { class DFMesh @@ -11,8 +13,7 @@ namespace diffCheck::geometry DFMesh() = default; ~DFMesh() = default; - ///< Convertes - public: + public: ///< Convertes /** * @brief Convert a open3d triangle mesh to our datatype * @@ -27,8 +28,15 @@ namespace diffCheck::geometry */ std::shared_ptr Cvt2O3DTriangleMesh(); - ///< I/O loader - public: + public: ///< Transformers + /** + * @brief Apply a transformation to the mesh + * + * @param transformation the transformation to apply + */ + void ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation); + + public: ///< I/O loader /** * @brief Read a mesh from a file * @@ -36,15 +44,13 @@ namespace diffCheck::geometry */ void LoadFromPLY(const std::string &path); - ///< Getters - public: + public: ///< Getters /// @brief Number of vertices in the mesh int GetNumVertices() const { return this->Vertices.size(); } /// @brief Number of faces in the mesh int GetNumFaces() const { return this->Faces.size(); } - ///< Basic mesh data - public: + public: ///< Basic mesh data /// @brief Eigen vector of 3D vertices std::vector Vertices; /// @brief Eigen vector of faces diff --git a/src/diffCheck/geometry/DFPointCloud.cc b/src/diffCheck/geometry/DFPointCloud.cc index 39850e97..f9d4014d 100644 --- a/src/diffCheck/geometry/DFPointCloud.cc +++ b/src/diffCheck/geometry/DFPointCloud.cc @@ -33,6 +33,25 @@ namespace diffCheck::geometry return O3DPointCloud; } + std::vector DFPointCloud::ComputeP2PDistance(std::shared_ptr target) + { + std::vector errors; + auto O3DSourcePointCloud = this->Cvt2O3DPointCloud(); + auto O3DTargetPointCloud = target->Cvt2O3DPointCloud(); + + std::vector distances; + + distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud); + return distances; + } + + void DFPointCloud::ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation) + { + auto O3DPointCloud = this->Cvt2O3DPointCloud(); + O3DPointCloud->Transform(transformation.TransformationMatrix); + this->Cvt2DFPointCloud(O3DPointCloud); + } + void DFPointCloud::LoadFromPLY(const std::string &path) { auto cloud = diffCheck::io::ReadPLYPointCloud(path); diff --git a/src/diffCheck/geometry/DFPointCloud.hh b/src/diffCheck/geometry/DFPointCloud.hh index 285f14cc..8e53234b 100644 --- a/src/diffCheck/geometry/DFPointCloud.hh +++ b/src/diffCheck/geometry/DFPointCloud.hh @@ -3,6 +3,8 @@ #include #include +#include + namespace diffCheck::geometry { @@ -12,8 +14,8 @@ namespace diffCheck::geometry DFPointCloud() = default; ~DFPointCloud() = default; - ///< Converters from other point cloud datatypes libraries to our format - public: + + public: ///< Converters from other point cloud datatypes libraries to our format /** * @brief Converter from open3d point cloud to our datatype * @@ -28,8 +30,29 @@ namespace diffCheck::geometry */ std::shared_ptr Cvt2O3DPointCloud(); - ///< I/O loader - public: + public: ///< Utilities + /** + * @brief Compute the "point to point" distance between this and another point clouds. + * + * For every point in the source point cloud, it looks in the KDTree of the target point cloud and finds the closest point. + * It returns a vector of distances, one for each point in the source point cloud. + * + * @param target The target diffCheck point cloud + * @return std::vector A vector of distances, one for each point in the source point cloud. + * + * @see https://github.com/isl-org/Open3D/blob/main/cpp/open3d/geometry/PointCloud.cpp + */ + std::vector ComputeP2PDistance(std::shared_ptr target); + + public: ///< Transformers + /** + * @brief Apply a transformation to the point cloud + * + * @param transformation the transformation to apply + */ + void ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation); + + public: ///< I/O loader /** * @brief Read a point cloud from a file * @@ -37,8 +60,7 @@ namespace diffCheck::geometry */ void LoadFromPLY(const std::string &path); - ///< Getters - public: + public: ///< Getters /// @brief Number of points in the point cloud int GetNumPoints() const { return this->Points.size(); } /// @brief Number of colors in the point cloud @@ -46,8 +68,7 @@ namespace diffCheck::geometry /// @brief Number of normals in the point cloud int GetNumNormals() const { return this->Normals.size(); } - ///< Basic point cloud data - public: + public: ///< Basic point cloud data /// @brief Eigen vector of 3D points std::vector Points; /// @brief Eigen vector of 3D colors diff --git a/src/diffCheck/registration/globalregistration.cc b/src/diffCheck/registration/globalregistration.cc deleted file mode 100644 index 139ff220..00000000 --- a/src/diffCheck/registration/globalregistration.cc +++ /dev/null @@ -1,209 +0,0 @@ -#include "globalRegistration.hh" - -namespace diffCheck::registration -{ - std::vector GlobalRegistration::ComputeP2PDistance(std::shared_ptr source, std::shared_ptr target) - { - std::vector errors; - auto O3DSourcePointCloud = source->Cvt2O3DPointCloud(); - auto O3DTargetPointCloud = target->Cvt2O3DPointCloud(); - - std::vector distances; - - distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud); - return distances; - } - - std::vector GlobalRegistration::EvaluateRegistrations(std::shared_ptr source, - std::shared_ptr target, - std::vector> transforms) - { - std::vector errors; - for(int i = 0; i < transforms.size(); i++) - { - std::shared_ptr o3DPointCloud = source->Cvt2O3DPointCloud(); - std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(o3DPointCloud->Transform(transforms[i])); - std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); - dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); - std::vector registrationErrors = ComputeP2PDistance(dfPointCloudPtrAfterTrans, target); - errors.push_back(std::accumulate(registrationErrors.begin(), registrationErrors.end(), 0.0) / registrationErrors.size()); - } - return errors; - }; - - diffCheck::transformation::DFTransformation GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, - std::shared_ptr target, - bool voxelise, - double voxelSize, - double radiusKDTreeSearch, - int maxNeighborKDTreeSearch, - double maxCorrespondenceDistance, - int iterationNumber, - int maxTupleCount) - { - std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); - std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - - if (voxelise) - { - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); - } - - std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr option = std::make_shared(); - option->maximum_correspondence_distance_ = maxCorrespondenceDistance; - option->iteration_number_ = iterationNumber; - option->maximum_tuple_count_ = maxTupleCount; - - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(*sourceO3D, - *targetO3D, - *sourceFPFHFeatures, - *targetFPFHFeatures, - *option); - diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); - transformation.transformationMatrix = result.transformation_; - - return transformation; - } - - diffCheck::transformation::DFTransformation GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, - std::shared_ptr target, - bool voxelise, - double voxelSize, - double radiusKDTreeSearch, - int maxNeighborKDTreeSearch, - double maxCorrespondenceDistance, - int iterationNumber, - int maxTupleCount) - { - std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); - std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - - if (voxelise) - { - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); - } - - std::shared_ptr option = std::make_shared(); - option->maximum_correspondence_distance_ = maxCorrespondenceDistance; - option->iteration_number_ = iterationNumber; - option->maximum_tuple_count_ = maxTupleCount; - - std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - - - open3d::pipelines::registration::CorrespondenceSet correspondanceset; - correspondanceset = open3d::pipelines::registration::CorrespondencesFromFeatures(*sourceFPFHFeatures, *targetFPFHFeatures); - - auto result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnCorrespondence(*sourceO3D, - *targetO3D, - correspondanceset, - *option); - diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); - transformation.transformationMatrix = result.transformation_; - - return transformation; - } - - diffCheck::transformation::DFTransformation GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr source, - std::shared_ptr target, - bool voxelise, - double voxelSize, - double radiusKDTreeSearch, - int maxNeighborKDTreeSearch, - double maxCorrespondenceDistance, - int ransacN, - double correspondenceCheckerDistance , - int ransacMaxIteration, - double ransacConfidenceThreshold) - { - std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); - std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - - if (voxelise) - { - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); - } - - std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - - std::vector> correspondanceChecker; - open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance); - correspondanceChecker.push_back(checkerOnDistance); - - open3d::pipelines::registration::CorrespondenceSet correspondanceset; - correspondanceset = open3d::pipelines::registration::CorrespondencesFromFeatures(*sourceFPFHFeatures, *targetFPFHFeatures); - - auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnCorrespondence(*sourceO3D, - *targetO3D, - correspondanceset, - maxCorrespondenceDistance, - open3d::pipelines::registration::TransformationEstimationPointToPoint(), - ransacN, - correspondanceChecker, - open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); - diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); - transformation.transformationMatrix = result.transformation_; - - return transformation; - } - - diffCheck::transformation::DFTransformation GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr source, - std::shared_ptr target, - bool voxelise, - double voxelSize, - double radiusKDTreeSearch, - int maxNeighborKDTreeSearch, - double maxCorrespondenceDistance, - open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation, - int ransacN, - double correspondenceCheckerDistance , - int ransacMaxIteration, - double ransacConfidenceThreshold) - { - std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); - std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); - - if (voxelise) - { - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); - } - - std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::vector> correspondanceChecker; - open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance); - correspondanceChecker.push_back(checkerOnDistance); - - auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D, - *targetO3D, - *sourceFPFHFeatures, - *targetFPFHFeatures, - false, - maxCorrespondenceDistance, - transformationEstimation, - ransacN, - correspondanceChecker, - open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); - - diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(); - transformation.transformationMatrix = result.transformation_; - - return transformation; - } -} \ No newline at end of file diff --git a/src/diffCheck/registration/globalregistration.hh b/src/diffCheck/registration/globalregistration.hh deleted file mode 100644 index 98b04da3..00000000 --- a/src/diffCheck/registration/globalregistration.hh +++ /dev/null @@ -1,163 +0,0 @@ -#pragma once - -#include "diffCheck.hh" -#include -#include - -namespace diffCheck::registration -{ - -class GlobalRegistration -{ - public: - - /** - * @brief Compute the "point to point" distance between two point clouds. - * - * For every point in the source point cloud, it looks in the KDTree of the target point cloud and finds the closest point. - * It returns a vector of distances, one for each point in the source point cloud. - * - * @param source The source diffCheck point cloud - * @param target The target diffCheck point cloud - * @return std::vector A vector of distances, one for each point in the source point cloud. - * - * @see https://github.com/isl-org/Open3D/blob/main/cpp/open3d/geometry/PointCloud.cpp - */ - static std::vector ComputeP2PDistance(std::shared_ptr source, - std::shared_ptr target); - /** - * @brief Evaluate the registration of a source point cloud to a target point cloud by applying a transformation matrix to the source point cloud and evaluate the error between the transformed source point cloud and the target point cloud. - * - * @param source The source diffCheck point cloud - * @param target The target diffCheck point cloud - * @param transform The vector of transformation matrix we want to evaluate. they are applied to the source point cloud. - * @return std::vector A vector of mean distances, one for each transform. - */ - - static std::vector EvaluateRegistrations(std::shared_ptr source, - std::shared_ptr target, - std::vector> transforms); - - /** - * @brief Fast Global Registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds - * - * Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). - * point features historigrams generalize this concept by computing point features in a local neighborhood of a point, and are stored as higher-dimentional historigrams. Those historigrams are then used to compute a transformation between the source and target point clouds. - * - * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). - * - * @param source the source diffCheck point cloud - * @param target the target diffCheck point cloud - * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). - * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise. - * @param maxNeighborKDTreeSearch 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. - * @param maxCorrespondenceDistance the maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones. - * @param iterationNumber 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 - * @param maxTupleCount 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 - * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. - * - * @see https://www.open3d.org/docs/latest/cpp_api/classopen3d_1_1pipelines_1_1registration_1_1_registration_result.html#a6722256f1f3ddccb2c4ec8d724693974 for more information on the RegistrationResult object - * @see https://link.springer.com/content/pdf/10.1007/978-3-319-46475-6_47.pdf for the original article on Fast Global Registration - * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation for more information on PFH (from PCL, not Open3D) - * @see https://mediatum.ub.tum.de/doc/800632/941254.pdf for in-depth documentation on the theory - */ - static diffCheck::transformation::DFTransformation O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr source, - std::shared_ptr target, - bool voxelize = true, - double voxelSize = 0.01, - double radiusKDTreeSearch = 3, - int maxNeighborKDTreeSearch = 50, - double maxCorrespondenceDistance = 0.05, - int iterationNumber = 100, - int maxTupleCount = 500); - - /** - * @brief Fast Global Registration based on Correspondence using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds. Initially developped in open3d to allow other features then FPFH to be used. - * - * Little information on this registration method compared to Fast Global Registration Feature Matching. - * If understood correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them, instead of using all the feature historigrams. - * - * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). - * - * @param source the source diffCheck point cloud - * @param target the target diffCheck point cloud - * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). - * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - * @param iterationNumber the number of iterations to run the Fast Global Registration algorithm. - * @param maxTupleCount the maximum number of tuples to consider in the FPFH hyperspace - * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. - * - * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html (from PCL, not Open3D) - */ - static diffCheck::transformation::DFTransformation O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr source, - std::shared_ptr target, - bool voxelize = true, - double voxelSize = 0.01, - double radiusKDTreeSearch = 3, - int maxNeighborKDTreeSearch = 50, - double maxCorrespondenceDistance = 0.05, - int iterationNumber = 100, - int maxTupleCount = 500); - /** - * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds. - * - * Correspondances are computed between the source and target point clouds FPFH hyperspaces. - * Then, a transformation is computed that minimizes the error between the correspondances. - * If the error is above a certain threshold, the transformation is discarded and a new one is computed. - * - * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). - * - * @param source the source diffCheck point cloud - * @param target the target diffCheck point cloud - * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). - * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. - * @param correspondenceSetSize the number of correspondences to consider in the Ransac algorithm - * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. - */ - static diffCheck::transformation::DFTransformation O3DRansacOnCorrespondence(std::shared_ptr source, - std::shared_ptr target, - bool voxelize = true, - double voxelSize = 0.01, - double radiusKDTreeSearch = 3, - int maxNeighborKDTreeSearch = 50, - double maxCorrespondenceDistance = 0.05, - int ransacN = 3, - double correspondenceCheckerDistance = 0.05, - int ransacMaxIteration = 1000, - double ransacConfidenceThreshold = 0.999); - /** - * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds - * - * This method picks random points in the source point cloud, gets the FPFH of those points and find the closest points in the FPFH space of the target point cloud. If the transformation the two sets of point yields a low enough error, it is kept. - * - * @param source the source diffCheck point cloud - * @param target the target diffCheck point cloud - * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). - * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. - * @param transformationEstimation the transformation estimation method to use. By default, it uses a point to point transformation estimation. - * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute. - * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. - * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. - * - * @see https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC (from PCL, not Open3D) - */ - static diffCheck::transformation::DFTransformation O3DRansacOnFeatureMatching(std::shared_ptr source, - std::shared_ptr target, - bool voxelize = true, - double voxelSize = 0.01, - double radiusKDTreeSearch = 3, - int maxNeighborKDTreeSearch = 50, - double maxCorrespondenceDistance = 0.05, - open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = open3d::pipelines::registration::TransformationEstimationPointToPoint(false), - int ransacN = 3, - double correspondenceCheckerDistance = 0.05, - int ransacMaxIteration = 1000, - double ransacConfidenceThreshold = 0.999); -}; - -} \ No newline at end of file diff --git a/src/diffCheck/registration/.gitkeep b/src/diffCheck/registrations/.gitkeep similarity index 100% rename from src/diffCheck/registration/.gitkeep rename to src/diffCheck/registrations/.gitkeep diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.cc b/src/diffCheck/registrations/DFGlobalRegistrations.cc new file mode 100644 index 00000000..e7a35dc2 --- /dev/null +++ b/src/diffCheck/registrations/DFGlobalRegistrations.cc @@ -0,0 +1,110 @@ +#include "diffCheck/registrations/DFGlobalRegistrations.hh" + +namespace diffCheck::registrations +{ + std::vector DFGlobalRegistrations::EvaluateRegistrations( + std::shared_ptr source, + std::shared_ptr target, + std::vector> transforms) + { + std::vector errors; + for(int i = 0; i < transforms.size(); i++) + { + std::shared_ptr o3DPointCloud = source->Cvt2O3DPointCloud(); + std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(o3DPointCloud->Transform(transforms[i])); + std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); + dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); + std::vector registrationErrors = dfPointCloudPtrAfterTrans->ComputeP2PDistance(target); + errors.push_back(std::accumulate(registrationErrors.begin(), registrationErrors.end(), 0.0) / registrationErrors.size()); + } + return errors; + }; + + diffCheck::transformation::DFTransformation DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching( + std::shared_ptr source, + std::shared_ptr target, + bool voxelise, + double voxelSize, + double radiusKDTreeSearch, + int maxNeighborKDTreeSearch, + double maxCorrespondenceDistance, + int iterationNumber, + int maxTupleCount) + { + std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); + std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); + + if (voxelise) + { + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); + } + + std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + std::shared_ptr option = std::make_shared(); + option->maximum_correspondence_distance_ = maxCorrespondenceDistance; + option->iteration_number_ = iterationNumber; + option->maximum_tuple_count_ = maxTupleCount; + + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching( + *sourceO3D, + *targetO3D, + *sourceFPFHFeatures, + *targetFPFHFeatures, + *option); + diffCheck::transformation::DFTransformation transformation = + diffCheck::transformation::DFTransformation(result.transformation_); + + return transformation; + } + + diffCheck::transformation::DFTransformation DFGlobalRegistrations::O3DRansacOnFeatureMatching( + std::shared_ptr source, + std::shared_ptr target, + bool voxelise, + double voxelSize, + double radiusKDTreeSearch, + int maxNeighborKDTreeSearch, + double maxCorrespondenceDistance, + open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation, + int ransacN, + double correspondenceCheckerDistance , + int ransacMaxIteration, + double ransacConfidenceThreshold) + { + std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); + std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); + + if (voxelise) + { + sourceO3D->VoxelDownSample(voxelSize); + targetO3D->VoxelDownSample(voxelSize); + } + + std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, + open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + std::vector> correspondanceChecker; + open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance); + correspondanceChecker.push_back(checkerOnDistance); + + auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D, + *targetO3D, + *sourceFPFHFeatures, + *targetFPFHFeatures, + false, + maxCorrespondenceDistance, + transformationEstimation, + ransacN, + correspondanceChecker, + open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); + + diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(result.transformation_); + + return transformation; + } +} \ No newline at end of file diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.hh b/src/diffCheck/registrations/DFGlobalRegistrations.hh new file mode 100644 index 00000000..18bd5021 --- /dev/null +++ b/src/diffCheck/registrations/DFGlobalRegistrations.hh @@ -0,0 +1,96 @@ +#pragma once + +#include "diffCheck.hh" +#include +#include + +namespace diffCheck::registrations +{ + class DFGlobalRegistrations + { + public: ///< Open3d registrations + /** + * @brief Fast Global Registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * + * Very simply, point features are values computed on a point cloud (for example the normal of a point, the curvature, etc.). + * point features historigrams generalize this concept by computing point features in a local neighborhood of a point, and are stored as + * higher-dimentional historigrams. Those historigrams are then used to compute a transformation between the source and target point clouds. + * + * @note The FPFH hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different). + * + * @param source the source diffCheck point cloud + * @param target the target diffCheck point cloud + * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise. + * @param maxNeighborKDTreeSearch 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. + * @param maxCorrespondenceDistance the maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones. + * @param iterationNumber 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 + * @param maxTupleCount 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 + * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. + * + * @see https://www.open3d.org/docs/latest/cpp_api/classopen3d_1_1pipelines_1_1registration_1_1_registration_result.html#a6722256f1f3ddccb2c4ec8d724693974 for more information on the RegistrationResult object + * @see https://link.springer.com/content/pdf/10.1007/978-3-319-46475-6_47.pdf for the original article on Fast Global Registration + * @see https://pcl.readthedocs.io/projects/tutorials/en/latest/pfh_estimation.html#pfh-estimation for more information on PFH (from PCL, not Open3D) + * @see https://mediatum.ub.tum.de/doc/800632/941254.pdf for in-depth documentation on the theory + */ + static diffCheck::transformation::DFTransformation O3DFastGlobalRegistrationFeatureMatching( + std::shared_ptr source, + std::shared_ptr target, + bool voxelize = true, + double voxelSize = 0.01, + double radiusKDTreeSearch = 3, + int maxNeighborKDTreeSearch = 50, + double maxCorrespondenceDistance = 0.05, + int iterationNumber = 100, + int maxTupleCount = 500); + /** + * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds + * + * This method picks random points in the source point cloud, gets the FPFH of those points and find the closest points in the FPFH space of + * the target point cloud. If the transformation the two sets of point yields a low enough error, it is kept. + * + * @param source the source diffCheck point cloud + * @param target the target diffCheck point cloud + * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures + * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. + * @param transformationEstimation the transformation estimation method to use. By default, it uses a point to point transformation estimation. + * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute. + * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. + * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. + * + * @see https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC (from PCL, not Open3D) + */ + static diffCheck::transformation::DFTransformation O3DRansacOnFeatureMatching( + std::shared_ptr source, + std::shared_ptr target, + bool voxelize = true, + double voxelSize = 0.01, + double radiusKDTreeSearch = 3, + int maxNeighborKDTreeSearch = 50, + double maxCorrespondenceDistance = 0.05, + open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = open3d::pipelines::registration::TransformationEstimationPointToPoint(false), + int ransacN = 3, + double correspondenceCheckerDistance = 0.05, + int ransacMaxIteration = 1000, + double ransacConfidenceThreshold = 0.999); + + private: ///< o3d utilities to evaluate registration errors + + /** + * @brief Evaluate the registration of a source point cloud to a target point cloud by applying a transformation matrix + * to the source point cloud and evaluate the error between the transformed source point cloud and the target point cloud. + * + * @param source The source diffCheck point cloud + * @param target The target diffCheck point cloud + * @param transform The vector of transformation matrix we want to evaluate. they are applied to the source point cloud. + * @return std::vector A vector of mean distances, one for each transform. + */ + + static std::vector EvaluateRegistrations(std::shared_ptr source, + std::shared_ptr target, + std::vector> transforms); + }; + +} \ No newline at end of file diff --git a/src/diffCheck/transformation/DFTransformation.cc b/src/diffCheck/transformation/DFTransformation.cc index 1da89be2..1d66cb24 100644 --- a/src/diffCheck/transformation/DFTransformation.cc +++ b/src/diffCheck/transformation/DFTransformation.cc @@ -1,5 +1,6 @@ #include "DFTransformation.hh" + namespace diffCheck::transformation { diff --git a/src/diffCheck/transformation/DFTransformation.hh b/src/diffCheck/transformation/DFTransformation.hh index e6e13ce1..6ce6119f 100644 --- a/src/diffCheck/transformation/DFTransformation.hh +++ b/src/diffCheck/transformation/DFTransformation.hh @@ -5,21 +5,30 @@ namespace diffCheck::transformation { class DFTransformation { + public: + DFTransformation() = default; + DFTransformation(const Eigen::Matrix4d& transformationMatrix) + : TransformationMatrix(transformationMatrix) + {} + DFTransformation(const Eigen::Matrix3d& rotationMatrix, const Eigen::Vector3d& translationVector) + : RotationMatrix(rotationMatrix), TranslationVector(translationVector) + {} + public: /** * @brief 4x4 Transformation matrix for point clouds */ - Eigen::Matrix4d transformationMatrix; + Eigen::Matrix4d TransformationMatrix; /** * @brief 3x3 Rotation matrix for point clouds */ - Eigen::Matrix3d rotationMatrix; + Eigen::Matrix3d RotationMatrix; /** * @brief 3x1 Translation vector for point clouds */ - Eigen::Vector3d translationVector; + Eigen::Vector3d TranslationVector; }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 8c936af7..257c2ce8 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -1,27 +1,21 @@ #include "diffCheck.hh" -#include -#include -#include -#include - #include -#include #include int main() { + // import clouds std::shared_ptr dfPointCloudPtr = std::make_shared(); std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruthNoNormals = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; - // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; + std::string pathCloud = R"(C:\Users\andre\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\andre\Downloads\00_mesh.ply)"; dfMeshPtr->LoadFromPLY(pathMesh); dfPointCloudPtr->LoadFromPLY(pathCloud); @@ -32,67 +26,41 @@ int main() dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.1 ; } -int iterations = 50; - // populate the mesh with points and store it in dfPointCloudPtrGroundTruth dfPointCloudPtrGroundTruthNoNormals->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); std::shared_ptr pcd = dfPointCloudPtrGroundTruthNoNormals->Cvt2O3DPointCloud(); pcd->EstimateNormals(); dfPointCloudPtrGroundTruth->Cvt2DFPointCloud(pcd); - std::vector transformations; - for (int i = 0; i < iterations; i++) - { - // create a rigid rotation matrix - Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); - T.block<3, 3>(0, 0) = Eigen::AngleAxisd(0.3*i, Eigen::Vector3d::UnitX()).toRotationMatrix(); - T(0, 3) = 30 * i; - T(1, 3) = -40 * i; - T(2, 3) = 60 * i; - transformations.push_back(T); - } - - - for (int i = 0; i < iterations; i++) - { - std::shared_ptr o3DPointCloud = dfPointCloudPtr->Cvt2O3DPointCloud(); - - std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(o3DPointCloud->Transform(transformations[i])); - dfPointCloudPtrAfterTrans = std::make_shared(); - - dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); - - std::vector> registrationResults; - // Testing the Fast Global Registration on Feature Matching method - std::shared_ptr dfPointCloudPtrAfterReg_1 = std::make_shared(); - diffCheck::transformation::DFTransformation result_1 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation = result_1.transformationMatrix; - registrationResults.push_back(transformation); - - // Testing the Fast Global Registration on Correspondance method - std::shared_ptr dfPointCloudPtrAfterReg_2 = std::make_shared(); - auto result_2 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation_2 = result_2.transformationMatrix; - registrationResults.push_back(transformation_2); - - // Testing the Ransac registration based on correspondance method - std::shared_ptr dfPointCloudPtrAfterReg_3 = std::make_shared(); - auto result_3 = diffCheck::registration::GlobalRegistration::O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation_3 = result_3.transformationMatrix; - registrationResults.push_back(transformation_3); - - // Testing the Ransac registration based on Feature Matching method - std::shared_ptr dfPointCloudPtrAfterReg_4 = std::make_shared(); - auto result_4 = diffCheck::registration::GlobalRegistration::O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans, dfPointCloudPtrGroundTruth); - Eigen::Matrix transformation_4 = result_4.transformationMatrix; - registrationResults.push_back(transformation_4); - - std::cout<<"Iteration: "< errors = diffCheck::registration::GlobalRegistration::EvaluateRegistrations(dfPointCloudPtrAfterTrans, dfPointCloudPtr, registrationResults); - std::cout<<"Errors: FGRCorrespondence "<(0, 0) = Eigen::AngleAxisd(0.3, Eigen::Vector3d::UnitX()).toRotationMatrix(); + T(0, 3) = 5; + T(1, 3) = -10; + T(2, 3) = 10; + dfPointCloudPtr->ApplyTransformation(diffCheck::transformation::DFTransformation(T)); + dfPointCloudPtrAfterTrans = dfPointCloudPtr; + + // test global registrations Fast and RANSAC-based + std::vector registrationResults; + + diffCheck::transformation::DFTransformation transformationA = + diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr, dfPointCloudPtrAfterTrans); + std::cout << "Fast transformation: " << transformationA.TransformationMatrix << std::endl; + dfPointCloudPtrAfterTrans->ApplyTransformation(transformationA); + registrationResults.push_back(transformationA); + + diffCheck::transformation::DFTransformation transformationB = + diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtr, dfPointCloudPtrAfterTrans); + std::cout << "Ransac transformation: " << transformationB.TransformationMatrix << std::endl; + dfPointCloudPtrAfterTrans->ApplyTransformation(transformationB); + registrationResults.push_back(transformationB); + + // visualize cloud + std::shared_ptr visualizer = std::make_shared(); + visualizer->AddPointCloud(dfPointCloudPtr); + visualizer->AddPointCloud(dfPointCloudPtrAfterTrans); + visualizer->Run(); return 0; } \ No newline at end of file From 6b06583209197404f7a58455bbc086c636fd017c Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 22 Apr 2024 14:49:29 +0200 Subject: [PATCH 070/141] WIP: refined registrations implemented --- src/diffCheck/registration/refinedRegistration.cc | 11 +++++++++++ src/diffCheck/registration/refinedRegistration.hh | 3 +++ 2 files changed, 14 insertions(+) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0de763bb..0235a586 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -6,6 +6,17 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) { std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index 4bec4ced..edc5cb1e 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,5 +11,8 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); + static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file From 0647d706b6ddbfe99eb0d2176ce15aca0b0e19fa Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 22 Apr 2024 15:05:57 +0200 Subject: [PATCH 071/141] FIX: small typo in CONTRIBUTING.md --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 920dae8f..7f0aa49b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -54,7 +54,7 @@ git commit -m "Remove a submodule name" ### Naming & synthax convention Here's the naming convention for this project: - ` `: lowerCamelCase. -- `type PrivateVariable`: public member of a class +- `type PublicVariable`: public member of a class - `type m_PrivateVariable`: Hungarian notation with UpperCamelCase for private class members. - `static type s_StaticVariable`: Hungarian notation with UpperCamelCase for static members of class. - `APP_SPEC`: Constants with SNAKE_UPPER_CASE. From 5a8d9d935d99e03934eea0d76500584d6fde6888 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Mon, 22 Apr 2024 16:17:07 +0200 Subject: [PATCH 072/141] FIX: minors --- src/diffCheck/registrations/DFGlobalRegistrations.hh | 1 - src/diffCheck/transformation/DFTransformation.hh | 3 +-- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.hh b/src/diffCheck/registrations/DFGlobalRegistrations.hh index 18bd5021..fdde0d36 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.hh +++ b/src/diffCheck/registrations/DFGlobalRegistrations.hh @@ -77,7 +77,6 @@ namespace diffCheck::registrations double ransacConfidenceThreshold = 0.999); private: ///< o3d utilities to evaluate registration errors - /** * @brief Evaluate the registration of a source point cloud to a target point cloud by applying a transformation matrix * to the source point cloud and evaluate the error between the transformed source point cloud and the target point cloud. diff --git a/src/diffCheck/transformation/DFTransformation.hh b/src/diffCheck/transformation/DFTransformation.hh index 6ce6119f..e45b86ba 100644 --- a/src/diffCheck/transformation/DFTransformation.hh +++ b/src/diffCheck/transformation/DFTransformation.hh @@ -29,6 +29,5 @@ namespace diffCheck::transformation * @brief 3x1 Translation vector for point clouds */ Eigen::Vector3d TranslationVector; - - }; + }; } \ No newline at end of file From 7ecfe27eea4429bb6a269675cd296801847fe47d Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Wed, 24 Apr 2024 10:16:11 +0200 Subject: [PATCH 073/141] FIX: replaced bool parameter with instation in default parameter (badpractice) --- deps/eigen | 2 +- src/diffCheck/registrations/DFGlobalRegistrations.cc | 5 ++++- src/diffCheck/registrations/DFGlobalRegistrations.hh | 4 ++-- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/deps/eigen b/deps/eigen index 2265242a..34967b0b 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 2265242aa121742dd7e80a0167228b43e95bec62 +Subproject commit 34967b0b5ba974cddd06c3a957e6b42ba620ed22 diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.cc b/src/diffCheck/registrations/DFGlobalRegistrations.cc index e7a35dc2..53012ac4 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.cc +++ b/src/diffCheck/registrations/DFGlobalRegistrations.cc @@ -69,7 +69,7 @@ namespace diffCheck::registrations double radiusKDTreeSearch, int maxNeighborKDTreeSearch, double maxCorrespondenceDistance, - open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation, + bool isTEstimatePt2Pt, int ransacN, double correspondenceCheckerDistance , int ransacMaxIteration, @@ -78,6 +78,9 @@ namespace diffCheck::registrations std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = + open3d::pipelines::registration::TransformationEstimationPointToPoint(isTEstimatePt2Pt); + if (voxelise) { sourceO3D->VoxelDownSample(voxelSize); diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.hh b/src/diffCheck/registrations/DFGlobalRegistrations.hh index fdde0d36..2da12b59 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.hh +++ b/src/diffCheck/registrations/DFGlobalRegistrations.hh @@ -55,7 +55,7 @@ namespace diffCheck::registrations * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. - * @param transformationEstimation the transformation estimation method to use. By default, it uses a point to point transformation estimation. + * @param isTEstimatePt2Pt the transformation estimation method to use. By default, it uses a point to point transformation estimation. If true it will scale and deform the cloud. * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute. * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. @@ -70,7 +70,7 @@ namespace diffCheck::registrations double radiusKDTreeSearch = 3, int maxNeighborKDTreeSearch = 50, double maxCorrespondenceDistance = 0.05, - open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = open3d::pipelines::registration::TransformationEstimationPointToPoint(false), + bool isTEstimatePt2Pt = false, int ransacN = 3, double correspondenceCheckerDistance = 0.05, int ransacMaxIteration = 1000, From 3885182a9ab837aae89158be1e28bad0952a71ca Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 25 Apr 2024 11:37:11 +0200 Subject: [PATCH 074/141] WIP: ApplyTransformation method --- src/diffCheck/geometry/DFPointCloud.cc | 3 ++ .../registrations/DFGlobalRegistrations.hh | 5 +-- src/diffCheckApp.cc | 37 +++++++++---------- 3 files changed, 22 insertions(+), 23 deletions(-) diff --git a/src/diffCheck/geometry/DFPointCloud.cc b/src/diffCheck/geometry/DFPointCloud.cc index f9d4014d..8e603271 100644 --- a/src/diffCheck/geometry/DFPointCloud.cc +++ b/src/diffCheck/geometry/DFPointCloud.cc @@ -49,6 +49,9 @@ namespace diffCheck::geometry { auto O3DPointCloud = this->Cvt2O3DPointCloud(); O3DPointCloud->Transform(transformation.TransformationMatrix); + this->Points.clear(); + this->Colors.clear(); + this->Normals.clear(); this->Cvt2DFPointCloud(O3DPointCloud); } diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.hh b/src/diffCheck/registrations/DFGlobalRegistrations.hh index fdde0d36..d153b7c0 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.hh +++ b/src/diffCheck/registrations/DFGlobalRegistrations.hh @@ -71,10 +71,10 @@ namespace diffCheck::registrations int maxNeighborKDTreeSearch = 50, double maxCorrespondenceDistance = 0.05, open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = open3d::pipelines::registration::TransformationEstimationPointToPoint(false), - int ransacN = 3, + int ransacN = 5, double correspondenceCheckerDistance = 0.05, int ransacMaxIteration = 1000, - double ransacConfidenceThreshold = 0.999); + double ransacConfidenceThreshold = 0.99); private: ///< o3d utilities to evaluate registration errors /** @@ -86,7 +86,6 @@ namespace diffCheck::registrations * @param transform The vector of transformation matrix we want to evaluate. they are applied to the source point cloud. * @return std::vector A vector of mean distances, one for each transform. */ - static std::vector EvaluateRegistrations(std::shared_ptr source, std::shared_ptr target, std::vector> transforms); diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 257c2ce8..fa456f02 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -9,57 +9,54 @@ int main() { // import clouds std::shared_ptr dfPointCloudPtr = std::make_shared(); - std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruthNoNormals = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\andre\Downloads\00_pt.ply)"; - std::string pathMesh = R"(C:\Users\andre\Downloads\00_mesh.ply)"; + std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\04_mesh.ply)"; dfMeshPtr->LoadFromPLY(pathMesh); dfPointCloudPtr->LoadFromPLY(pathCloud); - // add noise to dfPointCloudPtr for (int i = 0; i < dfPointCloudPtr->Points.size(); i++) { - dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.1 ; + dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01 ; } // populate the mesh with points and store it in dfPointCloudPtrGroundTruth - dfPointCloudPtrGroundTruthNoNormals->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + dfPointCloudPtrGroundTruthNoNormals->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(1000)); std::shared_ptr pcd = dfPointCloudPtrGroundTruthNoNormals->Cvt2O3DPointCloud(); pcd->EstimateNormals(); dfPointCloudPtrGroundTruth->Cvt2DFPointCloud(pcd); - + // create a rigid rotation matrix Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); - T.block<3, 3>(0, 0) = Eigen::AngleAxisd(0.3, Eigen::Vector3d::UnitX()).toRotationMatrix(); - T(0, 3) = 5; - T(1, 3) = -10; - T(2, 3) = 10; + T.block<3, 3>(0, 0) = Eigen::AngleAxisd(3, Eigen::Vector3d::UnitX()).toRotationMatrix(); + T(0, 3) = 50; + T(1, 3) = -100; + T(2, 3) = 100; dfPointCloudPtr->ApplyTransformation(diffCheck::transformation::DFTransformation(T)); - dfPointCloudPtrAfterTrans = dfPointCloudPtr; + std::shared_ptr dfPointCloudPtrCopy = std::make_shared(*dfPointCloudPtr); // test global registrations Fast and RANSAC-based std::vector registrationResults; - diffCheck::transformation::DFTransformation transformationA = - diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr, dfPointCloudPtrAfterTrans); - std::cout << "Fast transformation: " << transformationA.TransformationMatrix << std::endl; - dfPointCloudPtrAfterTrans->ApplyTransformation(transformationA); + diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr, dfPointCloudPtrGroundTruth, true, 0.01, 1, 50, 1, 500, 500); + std::cout << "Fast transformation: " << transformationA.TransformationMatrix << std::flush; + dfPointCloudPtr->ApplyTransformation(transformationA); registrationResults.push_back(transformationA); - diffCheck::transformation::DFTransformation transformationB = - diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtr, dfPointCloudPtrAfterTrans); + diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtrCopy, dfPointCloudPtrGroundTruth); std::cout << "Ransac transformation: " << transformationB.TransformationMatrix << std::endl; - dfPointCloudPtrAfterTrans->ApplyTransformation(transformationB); + dfPointCloudPtrCopy->ApplyTransformation(transformationB); registrationResults.push_back(transformationB); // visualize cloud std::shared_ptr visualizer = std::make_shared(); visualizer->AddPointCloud(dfPointCloudPtr); - visualizer->AddPointCloud(dfPointCloudPtrAfterTrans); + visualizer->AddPointCloud(dfPointCloudPtrCopy); + visualizer->AddMesh(dfMeshPtr); visualizer->Run(); return 0; From 61b6fc1fefe23d55a741c1eeb992c331415b569e Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 12:46:46 +0200 Subject: [PATCH 075/141] ADD: bounding box member for DFPointCloud class --- src/diffCheck/geometry/DFPointCloud.cc | 10 ++++++++++ src/diffCheck/geometry/DFPointCloud.hh | 9 +++++++++ 2 files changed, 19 insertions(+) diff --git a/src/diffCheck/geometry/DFPointCloud.cc b/src/diffCheck/geometry/DFPointCloud.cc index 8e603271..8ed165d6 100644 --- a/src/diffCheck/geometry/DFPointCloud.cc +++ b/src/diffCheck/geometry/DFPointCloud.cc @@ -45,6 +45,16 @@ namespace diffCheck::geometry return distances; } + std::vector DFPointCloud::ComputeBoundingBox() + { + auto O3DPointCloud = this->Cvt2O3DPointCloud(); + auto boundingBox = O3DPointCloud->GetAxisAlignedBoundingBox(); + std::vector extremePoints; + extremePoints.push_back(boundingBox.GetMinBound()); + extremePoints.push_back(boundingBox.GetMaxBound()); + this->BoundingBox = extremePoints; + return extremePoints; + } void DFPointCloud::ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation) { auto O3DPointCloud = this->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/geometry/DFPointCloud.hh b/src/diffCheck/geometry/DFPointCloud.hh index 8e53234b..a1b9b314 100644 --- a/src/diffCheck/geometry/DFPointCloud.hh +++ b/src/diffCheck/geometry/DFPointCloud.hh @@ -44,6 +44,13 @@ namespace diffCheck::geometry */ std::vector ComputeP2PDistance(std::shared_ptr target); + /** + * @brief Compute the bounding box of the point cloud and stores it as member of the DFPointCloud object + * + * @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 ComputeBoundingBox(); + public: ///< Transformers /** * @brief Apply a transformation to the point cloud @@ -75,5 +82,7 @@ namespace diffCheck::geometry std::vector Colors; /// @brief Eigen vector of 3D normals std::vector Normals; + /// @brief Eigen vector of two 3D vectors forming the bounnding box. + std::vector BoundingBox; }; } // namespace diffCheck::geometry \ No newline at end of file From ac494dfb4f46c5c529a5cc71adfc493f5a9e2401 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 12:49:48 +0200 Subject: [PATCH 076/141] FIX-ADD: registrations now with relative parameters for voxelization and RadiusKDTreeSearch --- .../registrations/DFGlobalRegistrations.cc | 62 +++++++++++++------ .../registrations/DFGlobalRegistrations.hh | 26 ++++---- 2 files changed, 59 insertions(+), 29 deletions(-) diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.cc b/src/diffCheck/registrations/DFGlobalRegistrations.cc index 53012ac4..5c6c2f1b 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.cc +++ b/src/diffCheck/registrations/DFGlobalRegistrations.cc @@ -36,14 +36,26 @@ namespace diffCheck::registrations if (voxelise) { - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); + double absoluteVoxelSize = voxelSize * sourceO3D->GetMaxBound().norm(); + sourceO3D->VoxelDownSample(absoluteVoxelSize); + targetO3D->VoxelDownSample(absoluteVoxelSize); } + if (sourceO3D->normals_.size() == 0) + { + sourceO3D->EstimateNormals(); + } + + if (targetO3D->normals_.size() == 0) + { + targetO3D->EstimateNormals(); + } + + double absoluteRadiusKDTreeSearch = radiusKDTreeSearch * sourceO3D->GetMaxBound().norm(); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr option = std::make_shared(); option->maximum_correspondence_distance_ = maxCorrespondenceDistance; option->iteration_number_ = iterationNumber; @@ -71,7 +83,8 @@ namespace diffCheck::registrations double maxCorrespondenceDistance, bool isTEstimatePt2Pt, int ransacN, - double correspondenceCheckerDistance , + double correspondenceCheckerDistance, + double similarityThreshold, int ransacMaxIteration, double ransacConfidenceThreshold) { @@ -83,28 +96,41 @@ namespace diffCheck::registrations if (voxelise) { - sourceO3D->VoxelDownSample(voxelSize); - targetO3D->VoxelDownSample(voxelSize); + double absoluteVoxelSize = voxelSize * (sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + sourceO3D->VoxelDownSample(absoluteVoxelSize); + targetO3D->VoxelDownSample(absoluteVoxelSize); + } + + if (sourceO3D->normals_.size() == 0) + { + sourceO3D->EstimateNormals(); + } + + if (targetO3D->normals_.size() == 0) + { + targetO3D->EstimateNormals(); } + double absoluteRadiusKDTreeSearch = radiusKDTreeSearch * sourceO3D->GetMaxBound().norm(); std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(radiusKDTreeSearch, maxNeighborKDTreeSearch)); + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); std::vector> correspondanceChecker; open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance); + open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength checkerOnEdgeLength = open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength(similarityThreshold); correspondanceChecker.push_back(checkerOnDistance); auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D, - *targetO3D, - *sourceFPFHFeatures, - *targetFPFHFeatures, - false, - maxCorrespondenceDistance, - transformationEstimation, - ransacN, - correspondanceChecker, - open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); + *targetO3D, + *sourceFPFHFeatures, + *targetFPFHFeatures, + true, + maxCorrespondenceDistance, + transformationEstimation, + ransacN, + correspondanceChecker, + open3d::pipelines::registration::RANSACConvergenceCriteria(ransacMaxIteration, ransacConfidenceThreshold)); diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(result.transformation_); diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.hh b/src/diffCheck/registrations/DFGlobalRegistrations.hh index 9d04b988..aa8b9bfd 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.hh +++ b/src/diffCheck/registrations/DFGlobalRegistrations.hh @@ -38,11 +38,11 @@ namespace diffCheck::registrations std::shared_ptr target, bool voxelize = true, double voxelSize = 0.01, - double radiusKDTreeSearch = 3, - int maxNeighborKDTreeSearch = 50, - double maxCorrespondenceDistance = 0.05, - int iterationNumber = 100, - int maxTupleCount = 500); + double radiusKDTreeSearch = 0.05, + int maxNeighborKDTreeSearch = 20, + double maxCorrespondenceDistance = 10, + int iterationNumber = 64, + int maxTupleCount = 1000); /** * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds * @@ -51,13 +51,16 @@ namespace diffCheck::registrations * * @param source the source diffCheck point cloud * @param target the target diffCheck point cloud - * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). - * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures + * @param voxelSize the size of the voxels used to downsample the point clouds. It is expressed relative to the point cloud size (0.01 means voxelSize = 1% of maxSize(pointCloud). A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch 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 * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. * @param isTEstimatePt2Pt the transformation estimation method to use. By default, it uses a point to point transformation estimation. If true it will scale and deform the cloud. * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute. - * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. + * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. + * @param similarityThreshold the threshold for the ransac check based on edge length to consider a model as inlier. A higher value will be stricter, discarding more ransac models. + * @param ransacMaxIteration the maximum number of iterations to run the Ransac algorithm. A higher value will take more time to compute but increases the chances of finding a good transformation. + * @param ransacConfidenceThreshold the threshold for the convergence criteria of the ransac models. A higher value will be stricter, discarding more ransac models. * @return diffCheck::transformation::DFTransformation The result of the registration, containing the transformation matrix and the fitness score. * * @see https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC (from PCL, not Open3D) @@ -67,14 +70,15 @@ namespace diffCheck::registrations std::shared_ptr target, bool voxelize = true, double voxelSize = 0.01, - double radiusKDTreeSearch = 3, + double radiusKDTreeSearch = 0.05, int maxNeighborKDTreeSearch = 50, double maxCorrespondenceDistance = 0.05, bool isTEstimatePt2Pt = false, int ransacN = 3, double correspondenceCheckerDistance = 0.05, - int ransacMaxIteration = 1000, - double ransacConfidenceThreshold = 0.99); + double similarityThreshold = 0.95, + int ransacMaxIteration = 100000, + double ransacConfidenceThreshold = 0.999); private: ///< o3d utilities to evaluate registration errors /** From 3338447261faf066cc5a92da425f06209c8f6150 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 12:56:30 +0200 Subject: [PATCH 077/141] WIP-ADD: add to ground truth from file + adaptations to implement small changes made to classes --- src/diffCheckApp.cc | 40 ++++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index fa456f02..4dea9e99 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -9,53 +9,57 @@ int main() { // import clouds std::shared_ptr dfPointCloudPtr = std::make_shared(); - std::shared_ptr dfPointCloudPtrGroundTruthNoNormals = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); + std::shared_ptr dfPointCloudPtrGroundTruthFromMesh = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\04_mesh.ply)"; + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; dfMeshPtr->LoadFromPLY(pathMesh); dfPointCloudPtr->LoadFromPLY(pathCloud); + dfPointCloudPtrGroundTruth->LoadFromPLY(pathCloud); + // add noise to dfPointCloudPtr + std::vector boundingBoxPoints = dfPointCloudPtr->ComputeBoundingBox(); + double meanInterval = (boundingBoxPoints[0] - boundingBoxPoints[1]).norm(); for (int i = 0; i < dfPointCloudPtr->Points.size(); i++) { - dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01 ; + dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.002 * meanInterval; } - - // populate the mesh with points and store it in dfPointCloudPtrGroundTruth - dfPointCloudPtrGroundTruthNoNormals->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(1000)); - std::shared_ptr pcd = dfPointCloudPtrGroundTruthNoNormals->Cvt2O3DPointCloud(); - pcd->EstimateNormals(); - dfPointCloudPtrGroundTruth->Cvt2DFPointCloud(pcd); + + // populate the mesh with points and store it in dfPointCloudPtrGroundTruthFromMesh + std::shared_ptr pcd_1 = dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(50000); + dfPointCloudPtrGroundTruthFromMesh->Cvt2DFPointCloud(pcd_1); // create a rigid rotation matrix Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); - T.block<3, 3>(0, 0) = Eigen::AngleAxisd(3, Eigen::Vector3d::UnitX()).toRotationMatrix(); - T(0, 3) = 50; - T(1, 3) = -100; - T(2, 3) = 100; + T.block<3, 3>(0, 0) = Eigen::AngleAxisd(1.57, Eigen::Vector3d::UnitX()).toRotationMatrix(); + T(0, 3) = 5; + T(1, 3) = -10; + T(2, 3) = 10; dfPointCloudPtr->ApplyTransformation(diffCheck::transformation::DFTransformation(T)); + + // create a copy of the point cloud so we can test both global registrations std::shared_ptr dfPointCloudPtrCopy = std::make_shared(*dfPointCloudPtr); // test global registrations Fast and RANSAC-based std::vector registrationResults; diffCheck::transformation::DFTransformation transformationA = - diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr, dfPointCloudPtrGroundTruth, true, 0.01, 1, 50, 1, 500, 500); - std::cout << "Fast transformation: " << transformationA.TransformationMatrix << std::flush; + diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr, dfPointCloudPtrGroundTruth); + std::cout << "Fast transformation: " << transformationA.TransformationMatrix << std::endl; dfPointCloudPtr->ApplyTransformation(transformationA); registrationResults.push_back(transformationA); diffCheck::transformation::DFTransformation transformationB = - diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtrCopy, dfPointCloudPtrGroundTruth); + diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtrCopy, dfPointCloudPtrGroundTruthFromMesh); std::cout << "Ransac transformation: " << transformationB.TransformationMatrix << std::endl; dfPointCloudPtrCopy->ApplyTransformation(transformationB); registrationResults.push_back(transformationB); // visualize cloud std::shared_ptr visualizer = std::make_shared(); - visualizer->AddPointCloud(dfPointCloudPtr); visualizer->AddPointCloud(dfPointCloudPtrCopy); + visualizer->AddPointCloud(dfPointCloudPtr); visualizer->AddMesh(dfMeshPtr); visualizer->Run(); From 028a7445451ced0748847539ba3b294b45b0030c Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 18:30:59 +0200 Subject: [PATCH 078/141] ADD: relative parameters, and tuned default values --- .../registrations/DFGlobalRegistrations.cc | 82 ++++++++++++++----- .../registrations/DFGlobalRegistrations.hh | 24 +++--- 2 files changed, 74 insertions(+), 32 deletions(-) diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.cc b/src/diffCheck/registrations/DFGlobalRegistrations.cc index 5c6c2f1b..b376eddd 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.cc +++ b/src/diffCheck/registrations/DFGlobalRegistrations.cc @@ -11,7 +11,10 @@ namespace diffCheck::registrations for(int i = 0; i < transforms.size(); i++) { std::shared_ptr o3DPointCloud = source->Cvt2O3DPointCloud(); - std::shared_ptr o3DPointCloudAfterTrans = std::make_shared(o3DPointCloud->Transform(transforms[i])); + + std::shared_ptr o3DPointCloudAfterTrans = + std::make_shared(o3DPointCloud->Transform(transforms[i])); + std::shared_ptr dfPointCloudPtrAfterTrans = std::make_shared(); dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans); std::vector registrationErrors = dfPointCloudPtrAfterTrans->ComputeP2PDistance(target); @@ -34,9 +37,12 @@ namespace diffCheck::registrations std::shared_ptr sourceO3D = source->Cvt2O3DPointCloud(); std::shared_ptr targetO3D = target->Cvt2O3DPointCloud(); + // voxelize at the scale of the point cloud if (voxelise) { - double absoluteVoxelSize = voxelSize * sourceO3D->GetMaxBound().norm(); + double absoluteVoxelSize = + voxelSize * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + sourceO3D->VoxelDownSample(absoluteVoxelSize); targetO3D->VoxelDownSample(absoluteVoxelSize); } @@ -51,24 +57,36 @@ namespace diffCheck::registrations targetO3D->EstimateNormals(); } - double absoluteRadiusKDTreeSearch = radiusKDTreeSearch * sourceO3D->GetMaxBound().norm(); - std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr option = std::make_shared(); + double absoluteRadiusKDTreeSearch = + radiusKDTreeSearch * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + + std::shared_ptr sourceFPFHFeatures = + open3d::pipelines::registration::ComputeFPFHFeature( + *sourceO3D, + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); + + std::shared_ptr targetFPFHFeatures = + open3d::pipelines::registration::ComputeFPFHFeature( + *targetO3D, + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); + + std::shared_ptr option = + std::make_shared(); + option->maximum_correspondence_distance_ = maxCorrespondenceDistance; option->iteration_number_ = iterationNumber; option->maximum_tuple_count_ = maxTupleCount; - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching( + + open3d::pipelines::registration::RegistrationResult result = + open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching( *sourceO3D, *targetO3D, *sourceFPFHFeatures, *targetFPFHFeatures, *option); diffCheck::transformation::DFTransformation transformation = - diffCheck::transformation::DFTransformation(result.transformation_); + diffCheck::transformation::DFTransformation(result.transformation_); return transformation; } @@ -94,9 +112,12 @@ namespace diffCheck::registrations open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = open3d::pipelines::registration::TransformationEstimationPointToPoint(isTEstimatePt2Pt); + // voxelize at the scale of the point cloud if (voxelise) { - double absoluteVoxelSize = voxelSize * (sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + double absoluteVoxelSize = + voxelSize * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + sourceO3D->VoxelDownSample(absoluteVoxelSize); targetO3D->VoxelDownSample(absoluteVoxelSize); } @@ -111,22 +132,43 @@ namespace diffCheck::registrations targetO3D->EstimateNormals(); } - double absoluteRadiusKDTreeSearch = radiusKDTreeSearch * sourceO3D->GetMaxBound().norm(); - std::shared_ptr sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D, - open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); - std::shared_ptr targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D, - open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); + // convert the relative values to absolute ones + double absoluteRadiusKDTreeSearch = + radiusKDTreeSearch * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + + double absoluteCorrespodenceCheckerDistance = + correspondenceCheckerDistance * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + + double absoluteMaxCorrespondenceDistance = + maxCorrespondenceDistance * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm()); + + std::shared_ptr sourceFPFHFeatures = + open3d::pipelines::registration::ComputeFPFHFeature( + *sourceO3D, + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); + + std::shared_ptr targetFPFHFeatures = + open3d::pipelines::registration::ComputeFPFHFeature( + *targetO3D, + open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch)); + std::vector> correspondanceChecker; - open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance); - open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength checkerOnEdgeLength = open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength(similarityThreshold); + + open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = + open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(absoluteCorrespodenceCheckerDistance); + + open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength checkerOnEdgeLength = + open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength(similarityThreshold); correspondanceChecker.push_back(checkerOnDistance); - auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D, + + auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching( + *sourceO3D, *targetO3D, *sourceFPFHFeatures, *targetFPFHFeatures, true, - maxCorrespondenceDistance, + absoluteMaxCorrespondenceDistance, transformationEstimation, ransacN, correspondanceChecker, diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.hh b/src/diffCheck/registrations/DFGlobalRegistrations.hh index aa8b9bfd..508c42b7 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.hh +++ b/src/diffCheck/registrations/DFGlobalRegistrations.hh @@ -20,8 +20,8 @@ namespace diffCheck::registrations * * @param source the source diffCheck point cloud * @param target the target diffCheck point cloud - * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points). - * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise. + * @param voxelSize the size of the voxels used to downsample the point clouds. It is expressed relative to the point cloud size (0.01 means voxelSize = 1% of maxSize(pointCloud). A higher value will result in a more coarse point cloud (less resulting points). + * @param radiusKDTreeSearch 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 * @param maxNeighborKDTreeSearch 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. * @param maxCorrespondenceDistance the maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones. * @param iterationNumber 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 @@ -37,11 +37,11 @@ namespace diffCheck::registrations std::shared_ptr source, std::shared_ptr target, bool voxelize = true, - double voxelSize = 0.01, - double radiusKDTreeSearch = 0.05, - int maxNeighborKDTreeSearch = 20, - double maxCorrespondenceDistance = 10, - int iterationNumber = 64, + double voxelSize = 0.005, + double radiusKDTreeSearch = 0.1, + int maxNeighborKDTreeSearch = 50, + double maxCorrespondenceDistance = 0.05, + int iterationNumber = 128, int maxTupleCount = 1000); /** * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds @@ -54,10 +54,10 @@ namespace diffCheck::registrations * @param voxelSize the size of the voxels used to downsample the point clouds. It is expressed relative to the point cloud size (0.01 means voxelSize = 1% of maxSize(pointCloud). A higher value will result in a more coarse point cloud (less resulting points). * @param radiusKDTreeSearch 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 * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures - * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. + * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. It is exprimed in relative values (it is scaled by the size of the bounding box of the poinnt cloud). * @param isTEstimatePt2Pt the transformation estimation method to use. By default, it uses a point to point transformation estimation. If true it will scale and deform the cloud. * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute. - * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. + * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. It is exprimed in relative values (it is scaled by the size of the bounding box of the poinnt cloud). * @param similarityThreshold the threshold for the ransac check based on edge length to consider a model as inlier. A higher value will be stricter, discarding more ransac models. * @param ransacMaxIteration the maximum number of iterations to run the Ransac algorithm. A higher value will take more time to compute but increases the chances of finding a good transformation. * @param ransacConfidenceThreshold the threshold for the convergence criteria of the ransac models. A higher value will be stricter, discarding more ransac models. @@ -69,14 +69,14 @@ namespace diffCheck::registrations std::shared_ptr source, std::shared_ptr target, bool voxelize = true, - double voxelSize = 0.01, - double radiusKDTreeSearch = 0.05, + double voxelSize = 0.005, + double radiusKDTreeSearch = 0.1, int maxNeighborKDTreeSearch = 50, double maxCorrespondenceDistance = 0.05, bool isTEstimatePt2Pt = false, int ransacN = 3, double correspondenceCheckerDistance = 0.05, - double similarityThreshold = 0.95, + double similarityThreshold = 0.9, int ransacMaxIteration = 100000, double ransacConfidenceThreshold = 0.999); From 169458a2a5653cd09f4c86d7265eca17d35e95b3 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 18:32:29 +0200 Subject: [PATCH 079/141] ADD: pipeline for overlapping point clouds --- src/diffCheckApp.cc | 46 +++++++++++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 16 deletions(-) diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 4dea9e99..6edadae0 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -9,15 +9,22 @@ int main() { // import clouds std::shared_ptr dfPointCloudPtr = std::make_shared(); + std::shared_ptr dfPointCloudPtr_1 = std::make_shared(); + std::shared_ptr dfPointCloudPtr_2 = std::make_shared(); + std::shared_ptr dfPointCloudPtrWithoutNormals = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruthFromMesh = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; + std::string pathCloud_1 = R"(C:\Users\localuser\Downloads\part_1_module.ply)"; + std::string pathCloud_2 = R"(C:\Users\localuser\Downloads\part_2_module.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\04_mesh.ply)"; dfMeshPtr->LoadFromPLY(pathMesh); dfPointCloudPtr->LoadFromPLY(pathCloud); + dfPointCloudPtr_1->LoadFromPLY(pathCloud_1); + dfPointCloudPtr_2->LoadFromPLY(pathCloud_2); dfPointCloudPtrGroundTruth->LoadFromPLY(pathCloud); // add noise to dfPointCloudPtr @@ -27,40 +34,47 @@ int main() { dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.002 * meanInterval; } + + std::shared_ptr pcd_1 = dfPointCloudPtr->Cvt2O3DPointCloud(); + if (pcd_1->normals_.size() > 0) + { + pcd_1->normals_.clear(); + } + dfPointCloudPtrWithoutNormals->Cvt2DFPointCloud(pcd_1); // populate the mesh with points and store it in dfPointCloudPtrGroundTruthFromMesh - std::shared_ptr pcd_1 = dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(50000); - dfPointCloudPtrGroundTruthFromMesh->Cvt2DFPointCloud(pcd_1); + std::shared_ptr pcd_2 = dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(50000); + dfPointCloudPtrGroundTruthFromMesh->Cvt2DFPointCloud(pcd_2); // create a rigid rotation matrix Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); T.block<3, 3>(0, 0) = Eigen::AngleAxisd(1.57, Eigen::Vector3d::UnitX()).toRotationMatrix(); - T(0, 3) = 5; - T(1, 3) = -10; - T(2, 3) = 10; - dfPointCloudPtr->ApplyTransformation(diffCheck::transformation::DFTransformation(T)); + T(0, 3) = 50; + T(1, 3) = -100; + T(2, 3) = 100; + dfPointCloudPtrWithoutNormals->ApplyTransformation(diffCheck::transformation::DFTransformation(T)); // create a copy of the point cloud so we can test both global registrations - std::shared_ptr dfPointCloudPtrCopy = std::make_shared(*dfPointCloudPtr); + std::shared_ptr dfPointCloudPtrCopy = std::make_shared(*dfPointCloudPtrWithoutNormals); // test global registrations Fast and RANSAC-based std::vector registrationResults; diffCheck::transformation::DFTransformation transformationA = - diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr, dfPointCloudPtrGroundTruth); + diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr_1, dfPointCloudPtr_2); std::cout << "Fast transformation: " << transformationA.TransformationMatrix << std::endl; - dfPointCloudPtr->ApplyTransformation(transformationA); + //dfPointCloudPtr_1->ApplyTransformation(transformationA); registrationResults.push_back(transformationA); diffCheck::transformation::DFTransformation transformationB = - diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtrCopy, dfPointCloudPtrGroundTruthFromMesh); + diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtr_1, dfPointCloudPtr_2); std::cout << "Ransac transformation: " << transformationB.TransformationMatrix << std::endl; - dfPointCloudPtrCopy->ApplyTransformation(transformationB); + dfPointCloudPtr_1->ApplyTransformation(transformationB); registrationResults.push_back(transformationB); // visualize cloud std::shared_ptr visualizer = std::make_shared(); - visualizer->AddPointCloud(dfPointCloudPtrCopy); - visualizer->AddPointCloud(dfPointCloudPtr); - visualizer->AddMesh(dfMeshPtr); + visualizer->AddPointCloud(dfPointCloudPtr_1); + visualizer->AddPointCloud(dfPointCloudPtr_2); + // visualizer->AddMesh(dfMeshPtr); visualizer->Run(); return 0; From f9c8ad9e7fd0c850ed913343f41caa182f1a97e5 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 18:33:22 +0200 Subject: [PATCH 080/141] ADD: loguru submodule --- .gitmodules | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitmodules b/.gitmodules index 43b52715..d895f0dc 100644 --- a/.gitmodules +++ b/.gitmodules @@ -11,3 +11,6 @@ [submodule "deps/boost"] path = deps/boost url = https://github.com/diffCheckOrg/submodule-boost.git +[submodule "deps/loguru"] + path = deps/loguru + url = https://github.com/emilk/loguru.git \ No newline at end of file From 487bff810aee4b34d899f698e029450f0f907525 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 18:51:56 +0200 Subject: [PATCH 081/141] FIX: indent --- src/diffCheck/registrations/DFGlobalRegistrations.hh | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/diffCheck/registrations/DFGlobalRegistrations.hh b/src/diffCheck/registrations/DFGlobalRegistrations.hh index 508c42b7..563ad85a 100644 --- a/src/diffCheck/registrations/DFGlobalRegistrations.hh +++ b/src/diffCheck/registrations/DFGlobalRegistrations.hh @@ -90,9 +90,10 @@ namespace diffCheck::registrations * @param transform The vector of transformation matrix we want to evaluate. they are applied to the source point cloud. * @return std::vector A vector of mean distances, one for each transform. */ - static std::vector EvaluateRegistrations(std::shared_ptr source, - std::shared_ptr target, - std::vector> transforms); + static std::vector EvaluateRegistrations( + std::shared_ptr source, + std::shared_ptr target, + std::vector> transforms); }; } \ No newline at end of file From ca9af48159caa06d4f1f4217398e9e43fdbedfb6 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 26 Apr 2024 18:57:15 +0200 Subject: [PATCH 082/141] FIX: trying to solve merge conflicts on .gitmodules and .vscode --- .gitmodules | 4 +-- .vscode/settings.json | 69 ++++++++++++++++++++----------------------- 2 files changed, 34 insertions(+), 39 deletions(-) diff --git a/.gitmodules b/.gitmodules index d895f0dc..14c31674 100644 --- a/.gitmodules +++ b/.gitmodules @@ -12,5 +12,5 @@ path = deps/boost url = https://github.com/diffCheckOrg/submodule-boost.git [submodule "deps/loguru"] - path = deps/loguru - url = https://github.com/emilk/loguru.git \ No newline at end of file + path = deps/loguru + url = https://github.com/emilk/loguru.git \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index 0aa6b7c9..8ffa8f3f 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,28 +1,18 @@ { "files.associations": { - "memory": "cpp", + "iostream": "cpp", + "string": "cpp", "algorithm": "cpp", - "any": "cpp", "array": "cpp", "atomic": "cpp", "bit": "cpp", - "bitset": "cpp", "cctype": "cpp", - "cfenv": "cpp", "charconv": "cpp", "chrono": "cpp", - "cinttypes": "cpp", "clocale": "cpp", "cmath": "cpp", - "codecvt": "cpp", "compare": "cpp", - "complex": "cpp", "concepts": "cpp", - "condition_variable": "cpp", - "coroutine": "cpp", - "csetjmp": "cpp", - "csignal": "cpp", - "cstdarg": "cpp", "cstddef": "cpp", "cstdint": "cpp", "cstdio": "cpp", @@ -30,52 +20,30 @@ "cstring": "cpp", "ctime": "cpp", "cwchar": "cpp", - "cwctype": "cpp", - "deque": "cpp", "exception": "cpp", - "execution": "cpp", "filesystem": "cpp", "format": "cpp", "forward_list": "cpp", - "fstream": "cpp", "functional": "cpp", - "future": "cpp", "initializer_list": "cpp", "iomanip": "cpp", "ios": "cpp", "iosfwd": "cpp", - "iostream": "cpp", "istream": "cpp", "iterator": "cpp", "limits": "cpp", "list": "cpp", "locale": "cpp", "map": "cpp", - "memory_resource": "cpp", - "mutex": "cpp", + "memory": "cpp", "new": "cpp", - "numeric": "cpp", "optional": "cpp", "ostream": "cpp", - "queue": "cpp", - "random": "cpp", - "ranges": "cpp", "ratio": "cpp", - "regex": "cpp", - "scoped_allocator": "cpp", - "set": "cpp", - "shared_mutex": "cpp", - "source_location": "cpp", - "span": "cpp", "sstream": "cpp", - "stack": "cpp", "stdexcept": "cpp", - "stop_token": "cpp", "streambuf": "cpp", - "string": "cpp", - "strstream": "cpp", "system_error": "cpp", - "thread": "cpp", "tuple": "cpp", "type_traits": "cpp", "typeindex": "cpp", @@ -83,8 +51,6 @@ "unordered_map": "cpp", "unordered_set": "cpp", "utility": "cpp", - "valarray": "cpp", - "variant": "cpp", "vector": "cpp", "xfacet": "cpp", "xhash": "cpp", @@ -102,6 +68,35 @@ "xtr1common": "cpp", "xtree": "cpp", "xutility": "cpp", + "any": "cpp", + "complex": "cpp", + "condition_variable": "cpp", + "csignal": "cpp", + "cstdarg": "cpp", + "deque": "cpp", + "execution": "cpp", + "fstream": "cpp", + "future": "cpp", + "mutex": "cpp", + "numeric": "cpp", + "queue": "cpp", + "random": "cpp", + "regex": "cpp", + "set": "cpp", + "span": "cpp", + "stop_token": "cpp", + "thread": "cpp", + "variant": "cpp", + "bitset": "cpp", + "cfenv": "cpp", + "ranges": "cpp", + "shared_mutex": "cpp", + "source_location": "cpp", + "stack": "cpp", + "valarray": "cpp", + "*.inc": "cpp", + "coroutine": "cpp", + "resumable": "cpp", "*.ipp": "cpp" } } \ No newline at end of file From 2085ae78dd59afab9d233a5cd7e7d92071736328 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 15:32:06 +0100 Subject: [PATCH 083/141] WIP: stashing before refactoring cmake project --- cmake/Dockerfile | 34 +++++++++++++++++++ cmake/install_open3d.bat | 71 +++++++++++++++++++--------------------- deps/eigen | 2 +- 3 files changed, 69 insertions(+), 38 deletions(-) create mode 100644 cmake/Dockerfile diff --git a/cmake/Dockerfile b/cmake/Dockerfile new file mode 100644 index 00000000..4bbe0042 --- /dev/null +++ b/cmake/Dockerfile @@ -0,0 +1,34 @@ +# Use the latest Windows Server Core image with .NET Framework 4.8. +FROM mcr.microsoft.com/windows/servercore:ltsc2019 + +# Restore the default Windows shell for correct batch processing. +SHELL ["cmd", "/S", "/C"] + +# Download and install CMake +ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi +RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait + +# Download and install Git +ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe +RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait + +# Download and install vcpkg +RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg +RUN C:\\vcpkg\\bootstrap-vcpkg.bat + +# Install Open3D and other dependencies with vcpkg +RUN C:\\vcpkg\\vcpkg install open3d +RUN C:\\vcpkg\\vcpkg integrate install + +# Set up the working directory +WORKDIR C:/project + +# Clone the project +RUN git clone https://github.com/yourusername/yourproject.git . + +# Run the build script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] +RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] + +# Set the entrypoint to your application's main executable +ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat index 1baaa281..981feb33 100644 --- a/cmake/install_open3d.bat +++ b/cmake/install_open3d.bat @@ -44,46 +44,43 @@ if not exist "%targetDir%" ( :: Download the file echo Downloading Open3D... -curl -L -o "%filePath%" "%url%" - -:: check if the file was downloaded if not wait -:wait -if not exist "%filePath%" ( - echo Waiting for download to complete... - timeout /t 5 /nobreak >nul - goto wait +curl -L -o "%targetDir%\open3d.zip" "%url%" + +:: Check if the file was downloaded +if not exist "%targetDir%\open3d.zip" ( + echo Failed to download Open3D. + exit /b 1 ) -echo File downloaded. :: Extract the file echo Extracting Open3D... powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" -:: Delete the downloaded zip file -del "%targetDir%\open3d.zip" - -:: Change to the target directory -cd /d "%targetDir%" - -:: Run the cmake commands -echo Building Open3D... -cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build -if errorlevel 1 ( - echo Failed to run cmake configuration command. - exit /b 1 -) - -cmake --build build --config Release --target ALL_BUILD -if errorlevel 1 ( - echo Failed to build ALL_BUILD. - exit /b 1 -) - -cmake --build build --config Release --target INSTALL -if errorlevel 1 ( - echo Failed to install. - exit /b 1 -) - -echo Done. -endlocal \ No newline at end of file +@REM :: Delete the downloaded zip file +@REM del "%targetDir%\open3d.zip" + +@REM :: Change to the target directory +@REM cd /d "%targetDir%" + +@REM :: Run the cmake commands +@REM echo Building Open3D... +@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build +@REM if errorlevel 1 ( +@REM echo Failed to run cmake configuration command. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target ALL_BUILD +@REM if errorlevel 1 ( +@REM echo Failed to build ALL_BUILD. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target INSTALL +@REM if errorlevel 1 ( +@REM echo Failed to install. +@REM exit /b 1 +@REM ) + +@REM echo Done. +@REM endlocal \ No newline at end of file diff --git a/deps/eigen b/deps/eigen index d26e1971..77833f93 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit d26e19714fca2faf544619c3604f88d980e5a207 +Subproject commit 77833f932040b46e79b6fa6522594a6df27e8a76 From e1ca01f9b35de649a960b67ad2f2cdcfea2e13bf Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:26:55 +0100 Subject: [PATCH 084/141] WIP: testing docker windows --- .gitmodules | 5 ++++- CMakeLists.txt | 20 +++++++++++--------- cmake/Dockerfile => Dockerfile | 19 +++++-------------- deps/open3d | 1 + src/diffCheckApp.cc | 7 ++++++- 5 files changed, 27 insertions(+), 25 deletions(-) rename cmake/Dockerfile => Dockerfile (65%) create mode 160000 deps/open3d diff --git a/.gitmodules b/.gitmodules index 1c09da21..dc61cae6 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,4 +4,7 @@ branch = main [submodule "deps/eigen"] path = deps/eigen - url = https://gitlab.com/libeigen/eigen.git \ No newline at end of file + url = https://gitlab.com/libeigen/eigen.git +[submodule "deps/open3d"] + path = deps/open3d + url = https://github.com/diffCheckOrg/submodule-open3d.git diff --git a/CMakeLists.txt b/CMakeLists.txt index 707e8c73..6044d044 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -52,7 +52,7 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (from system) ----------------------------------------------------- +# Open3D (pre-built binaries) ----------------------------------------------------- # The options need to be the same as Open3D's default # If Open3D is configured and built with custom options, you'll also need to # specify the same custom options. @@ -63,6 +63,8 @@ else() set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") endif() +download_submodule_project(open3d) +set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) # print the version debug or release of the package @@ -85,17 +87,17 @@ if(WIN32) endif() endif() -# Boost (from system) ----------------------------------------------------- -# download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download -find_package(Boost REQUIRED) +# # Boost (from system) ----------------------------------------------------- +# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download +# find_package(Boost REQUIRED) -# print boost include dir -message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") +# # print boost include dir +# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# CGAL (header-only) ------------------------------------------------------ -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# # CGAL (header-only) ------------------------------------------------------ +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/cmake/Dockerfile b/Dockerfile similarity index 65% rename from cmake/Dockerfile rename to Dockerfile index 4bbe0042..34b2c6f8 100644 --- a/cmake/Dockerfile +++ b/Dockerfile @@ -12,23 +12,14 @@ RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait -# Download and install vcpkg -RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg -RUN C:\\vcpkg\\bootstrap-vcpkg.bat - -# Install Open3D and other dependencies with vcpkg -RUN C:\\vcpkg\\vcpkg install open3d -RUN C:\\vcpkg\\vcpkg integrate install - # Set up the working directory WORKDIR C:/project -# Clone the project -RUN git clone https://github.com/yourusername/yourproject.git . +# make the code available in the container +COPY . . + +# Run the cmake/config.bat script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] # Run the build script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] - -# Set the entrypoint to your application's main executable -ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/deps/open3d b/deps/open3d new file mode 160000 index 00000000..1841ca54 --- /dev/null +++ b/deps/open3d @@ -0,0 +1 @@ +Subproject commit 1841ca5492a583075d0580828ae7edfa2a524675 diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index d3987bcd..ec0023bc 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -18,8 +18,13 @@ int main() std::string pathMesh = R"(F:\diffCheck\assets\dataset\mesh_fromRh_unfixedLength.ply)"; // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; - + // create a sphere from o3d + auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); dfMeshPtr->LoadFromPLY(pathMesh); + + + dfMeshPtr->Cvt2DFMesh(mesh); + // dfPointCloudPtr->LoadFromPLY(pathCloud); std::shared_ptr vis = std::make_shared(); From 04626cd06131bd5b65846b37ab65a3857b993f2b Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:30:49 +0100 Subject: [PATCH 085/141] FIX: updated version with bats for workflow --- .github/workflows/win-build.yml | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/.github/workflows/win-build.yml b/.github/workflows/win-build.yml index d5c3611e..c129d891 100644 --- a/.github/workflows/win-build.yml +++ b/.github/workflows/win-build.yml @@ -20,8 +20,6 @@ jobs: - uses: actions/checkout@v4 - name: CMAKE Configure - run: > - cmake -B ${{github.workspace}}/build -S ${{github.workspace}} - -D CMAKE_BUILD_TYPE=Release + run: ${{github.workspace}}/cmake/config.bat - name: CMake Build - run: cmake --build ${{github.workspace}}/build --config Release \ No newline at end of file + run: ${{github.workspace}}/cmake/build.bat \ No newline at end of file From 64218d1ee6da5f948416bb272fa6a17bab0e9ae0 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:38:41 +0100 Subject: [PATCH 086/141] WIP: testing different config for ci --- cmake/config.bat | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/config.bat b/cmake/config.bat index 941cbdbb..45ee3eeb 100644 --- a/cmake/config.bat +++ b/cmake/config.bat @@ -1 +1 @@ -cmake -S . -B build -G "Visual Studio 16 2019" -A x64 \ No newline at end of file +cmake -S . -B build \ No newline at end of file From d7baa30a445fcfb004eb5a9f27ee7a6a46946c9c Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:48:38 +0100 Subject: [PATCH 087/141] FIX: udpated correct istructions README --- .gitmodules | 3 ++ CMakeLists.txt | 16 ++++---- Dockerfile | 25 ------------ README.md | 20 ++-------- cmake/install_open3d.bat | 86 ---------------------------------------- deps/boost | 1 + deps/open3d | 2 +- src/diffCheck.hh | 2 - 8 files changed, 16 insertions(+), 139 deletions(-) delete mode 100644 Dockerfile delete mode 100644 cmake/install_open3d.bat create mode 160000 deps/boost diff --git a/.gitmodules b/.gitmodules index dc61cae6..43b52715 100644 --- a/.gitmodules +++ b/.gitmodules @@ -8,3 +8,6 @@ [submodule "deps/open3d"] path = deps/open3d url = https://github.com/diffCheckOrg/submodule-open3d.git +[submodule "deps/boost"] + path = deps/boost + url = https://github.com/diffCheckOrg/submodule-boost.git diff --git a/CMakeLists.txt b/CMakeLists.txt index 6044d044..215af0c9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -87,17 +87,17 @@ if(WIN32) endif() endif() -# # Boost (from system) ----------------------------------------------------- -# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download -# find_package(Boost REQUIRED) +# Boost (header only) ----------------------------------------------------- +download_submodule_project(boost) +target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# # print boost include dir -# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") +# print boost include dir +message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# # CGAL (header-only) ------------------------------------------------------ -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# CGAL (header-only) ------------------------------------------------------ +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index 34b2c6f8..00000000 --- a/Dockerfile +++ /dev/null @@ -1,25 +0,0 @@ -# Use the latest Windows Server Core image with .NET Framework 4.8. -FROM mcr.microsoft.com/windows/servercore:ltsc2019 - -# Restore the default Windows shell for correct batch processing. -SHELL ["cmd", "/S", "/C"] - -# Download and install CMake -ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi -RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait - -# Download and install Git -ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe -RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait - -# Set up the working directory -WORKDIR C:/project - -# make the code available in the container -COPY . . - -# Run the cmake/config.bat script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] - -# Run the build script -RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] diff --git a/README.md b/README.md index c4b7b85c..f21a5513 100644 --- a/README.md +++ b/README.md @@ -47,24 +47,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing it needs to be installed from source [from here](https://github.com/isl-org/Open3D/archive/refs/tags/v0.18.0.zip), unzip the file and by following the instructions below: -```terminal -cd open3d -mkdir build -cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="C:\Program Files\Open3D" -S . -B build -cmake --build build --config Release --target ALL_BUILD -cmake --build build --config Release --target INSTALL -``` -- `Eigen` for linear algebra (needed by `Open3d`) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) +- `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities, it needs to be installed from source [from the repo](https://github.com/boostorg/boost) as such: -```terminal -git clone --recursive https://github.com/boostorg/boost.git -cd boost -cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="C:\Program Files\Boost" -S . -B build -cmake --build build --config Release --target ALL_BUILD -cmake --build build --config Release --target INSTALL -``` +- `Boost` for general utilities as pre-build binaries ## How to build c++ project To build and test the project, follow the following steps: diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat deleted file mode 100644 index 981feb33..00000000 --- a/cmake/install_open3d.bat +++ /dev/null @@ -1,86 +0,0 @@ -@echo off -setlocal - -:: run the following in a pop up window to avoid the console window and ask to ru n ass admin -@echo off -:: BatchGotAdmin -:------------------------------------- -REM --> Check for permissions ->nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" - -REM --> If error flag set, we do not have admin. -if '%errorlevel%' NEQ '0' ( - echo Requesting administrative privileges... - goto UACPrompt -) else ( goto gotAdmin ) - -:UACPrompt - echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" - echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs" - - "%temp%\getadmin.vbs" - exit /B - -:gotAdmin - if exist "%temp%\getadmin.vbs" ( del "%temp%\getadmin.vbs" ) - pushd "%CD%" - CD /D "%~dp0" -:-------------------------------------- - - - -:: Define the download URL and the target directory -set "url=https://github.com/isl-org/Open3D/releases/download/v0.18.0/open3d-devel-windows-amd64-0.18.0.zip" -set "targetDir=C:\Program Files\Open3Dtest" - -:: Create the if the directory does not exist -if not exist "%targetDir%" mkdir "%targetDir% - -:: check if the directory was created -if not exist "%targetDir%" ( - echo Failed to create the target directory. - exit /b 1 -) - -:: Download the file -echo Downloading Open3D... -curl -L -o "%targetDir%\open3d.zip" "%url%" - -:: Check if the file was downloaded -if not exist "%targetDir%\open3d.zip" ( - echo Failed to download Open3D. - exit /b 1 -) - -:: Extract the file -echo Extracting Open3D... -powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" - -@REM :: Delete the downloaded zip file -@REM del "%targetDir%\open3d.zip" - -@REM :: Change to the target directory -@REM cd /d "%targetDir%" - -@REM :: Run the cmake commands -@REM echo Building Open3D... -@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build -@REM if errorlevel 1 ( -@REM echo Failed to run cmake configuration command. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target ALL_BUILD -@REM if errorlevel 1 ( -@REM echo Failed to build ALL_BUILD. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target INSTALL -@REM if errorlevel 1 ( -@REM echo Failed to install. -@REM exit /b 1 -@REM ) - -@REM echo Done. -@REM endlocal \ No newline at end of file diff --git a/deps/boost b/deps/boost new file mode 160000 index 00000000..ac8c15b5 --- /dev/null +++ b/deps/boost @@ -0,0 +1 @@ +Subproject commit ac8c15b524f752c839379d0ddcc1b4dded0998de diff --git a/deps/open3d b/deps/open3d index 1841ca54..498699b8 160000 --- a/deps/open3d +++ b/deps/open3d @@ -1 +1 @@ -Subproject commit 1841ca5492a583075d0580828ae7edfa2a524675 +Subproject commit 498699b89b204c69bbb70a856fd2ee2882990795 diff --git a/src/diffCheck.hh b/src/diffCheck.hh index a402d367..0c05498f 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,8 +1,6 @@ #pragma once -// include CGAL - #include // diffCheck includes From 87775ed7898ed5b3bdc9f601a2c48495e70ebcb4 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:50:21 +0100 Subject: [PATCH 088/141] FIX: udpated correct istructions README x2 --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index f21a5513..e52940c5 100644 --- a/README.md +++ b/README.md @@ -47,10 +47,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-open3d.git)) - `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities as pre-build binaries +- `Boost` for general utilities as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-boost.git)) ## How to build c++ project To build and test the project, follow the following steps: From 5f278b7a8f4a5a871a16ba148487837e87de1516 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 12:56:26 +0100 Subject: [PATCH 089/141] CAP: added logging --- .gitmodules | 3 +++ .vscode/settings.json | 3 ++- CMakeLists.txt | 34 +++++++++++++++++----------------- CONTRIBUTING.md | 22 ++++++++++++---------- cmake/options.cmake | 6 ++++++ deps/boost | 2 +- deps/eigen | 2 +- deps/loguru | 1 + deps/open3d | 2 +- diffCheckErrors.log | 4 ++++ diffCheckEvery.log | 6 ++++++ src/diffCheck.hh | 5 ++++- src/diffCheck/IOManager.cc | 36 ------------------------------------ src/diffCheck/log.cc | 22 ++++++++++++++++++++++ src/diffCheck/log.hh | 29 +++++++++++++++++++++++++++++ src/diffCheckApp.cc | 11 ++++++++--- 16 files changed, 117 insertions(+), 71 deletions(-) create mode 160000 deps/loguru create mode 100644 diffCheckErrors.log create mode 100644 diffCheckEvery.log create mode 100644 src/diffCheck/log.cc create mode 100644 src/diffCheck/log.hh diff --git a/.gitmodules b/.gitmodules index 43b52715..d1521ec4 100644 --- a/.gitmodules +++ b/.gitmodules @@ -11,3 +11,6 @@ [submodule "deps/boost"] path = deps/boost url = https://github.com/diffCheckOrg/submodule-boost.git +[submodule "deps/loguru"] + path = deps/loguru + url = https://github.com/emilk/loguru.git diff --git a/.vscode/settings.json b/.vscode/settings.json index 26812044..8ffa8f3f 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -96,6 +96,7 @@ "valarray": "cpp", "*.inc": "cpp", "coroutine": "cpp", - "resumable": "cpp" + "resumable": "cpp", + "*.ipp": "cpp" } } \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 215af0c9..3033fdb5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,8 +4,8 @@ set(CMAKE_CXX_STANDARD 17) list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) -# import the custom cmake utilities funcs include(external_tools) +include(options) # do a submodule init if not done already execute_process(COMMAND git submodule update --init --recursive @@ -17,6 +17,13 @@ if(NOT GIT_SUBMOD_RESULT EQUAL "0") endif() +#-------------------------------------------------------------------------- +# pre-compiled definitions +#-------------------------------------------------------------------------- +if(SILENT_LOGGING) + target_compile_definitions(${PROJECT_NAME} PRIVATE SILENT_LOGGING=true) +endif() + #-------------------------------------------------------------------------- # diffCheck dynamic lib #-------------------------------------------------------------------------- @@ -42,6 +49,9 @@ target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src ) + #set the MD_DynamicRelease flag for MSVC since we are compiling with /MD for py wrap +set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") + #-------------------------------------------------------------------------- # 3rd party @@ -52,17 +62,7 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (pre-built binaries) ----------------------------------------------------- -# The options need to be the same as Open3D's default -# If Open3D is configured and built with custom options, you'll also need to -# specify the same custom options. -option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) -if(STATIC_WINDOWS_RUNTIME) - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") -else() - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") -endif() - +# Open3D (pre-built binaries) --------------------------------------------- download_submodule_project(open3d) set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) @@ -91,14 +91,14 @@ endif() download_submodule_project(boost) target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# print boost include dir -message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") - -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) - # CGAL (header-only) ------------------------------------------------------ target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# loguru (header-only) ---------------------------------------------------- +download_submodule_project(loguru) +add_subdirectory(deps/loguru) +target_link_libraries(${SHARED_LIB_NAME} PUBLIC loguru::loguru) + #-------------------------------------------------------------------------- # executable for prototyping #-------------------------------------------------------------------------- diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 920dae8f..0e9e1d38 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -157,23 +157,25 @@ Follow [this guide for documenting the code](https://developer.lsst.io/cpp/api-d */ ``` --> - +``` ### I/O and basic datatypes Here's how you can import point cloud from file: diff --git a/cmake/options.cmake b/cmake/options.cmake index e69de29b..596e99fb 100644 --- a/cmake/options.cmake +++ b/cmake/options.cmake @@ -0,0 +1,6 @@ +# The options need to be the same as Open3D's default +# If Open3D is configured and built with custom options, you'll also need to +# specify the same custom options. +option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) + +option(SILENT_LOGGING "Do not log messages in the terminal if on." OFF) \ No newline at end of file diff --git a/deps/boost b/deps/boost index ac8c15b5..ee2a0a55 160000 --- a/deps/boost +++ b/deps/boost @@ -1 +1 @@ -Subproject commit ac8c15b524f752c839379d0ddcc1b4dded0998de +Subproject commit ee2a0a555b6fe33458ae19bfa1e193d8e67bb6e9 diff --git a/deps/eigen b/deps/eigen index 77833f93..e63d9f6c 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 77833f932040b46e79b6fa6522594a6df27e8a76 +Subproject commit e63d9f6ccb7f6f29f31241b87c542f3f0ab3112b diff --git a/deps/loguru b/deps/loguru new file mode 160000 index 00000000..4adaa185 --- /dev/null +++ b/deps/loguru @@ -0,0 +1 @@ +Subproject commit 4adaa185883e3c04da25913579c451d3c32cfac1 diff --git a/deps/open3d b/deps/open3d index 498699b8..7f83ddfc 160000 --- a/deps/open3d +++ b/deps/open3d @@ -1 +1 @@ -Subproject commit 498699b89b204c69bbb70a856fd2ee2882990795 +Subproject commit 7f83ddfcbbb512824f358c365a3c62f6cd246f87 diff --git a/diffCheckErrors.log b/diffCheckErrors.log new file mode 100644 index 00000000..092b5e99 --- /dev/null +++ b/diffCheckErrors.log @@ -0,0 +1,4 @@ +arguments: loguru +Current dir: F:\diffCheck +File verbosity level: -2 +date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log new file mode 100644 index 00000000..20fc75ab --- /dev/null +++ b/diffCheckEvery.log @@ -0,0 +1,6 @@ +arguments: loguru +Current dir: F:\diffCheck +File verbosity level: 9 +date time ( uptime ) [ thread name/id ] file:line v| +2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckEvery.log', mode: 'w', verbosity: 9 +2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckErrors.log', mode: 'w', verbosity: -2 diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 0c05498f..49ceec74 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,9 +1,12 @@ #pragma once - #include +#include // diffCheck includes +#include "diffCheck/log.hh" +diffCheck::Log LOG = diffCheck::Log(); + #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" #include "diffCheck/IOManager.hh" diff --git a/src/diffCheck/IOManager.cc b/src/diffCheck/IOManager.cc index 1d1dc171..dc5cc98d 100644 --- a/src/diffCheck/IOManager.cc +++ b/src/diffCheck/IOManager.cc @@ -2,13 +2,6 @@ #include -// #include -// #include -// #include - -// typedef CGAL::Simple_cartesian Kernel; -// typedef CGAL::Polyhedron_3 Polyhedron; - namespace diffCheck::io { @@ -26,35 +19,6 @@ namespace diffCheck::io std::shared_ptr open3dMesh = open3d::io::CreateMeshFromFile(filename); mesh->Cvt2DFMesh(open3dMesh); - // bool isFromRhino = false; - // std::ifstream file(filename); - // std::string line; - // while (std::getline(file, line)) - // { - // if (line.find("Rhinoeros") != std::string::npos) - // { - // isFromRhino = true; - // break; - // } - // } - // file.close(); - // std::cout << "isFromRhino: " << isFromRhino << std::endl; - - - // bool isFixedLength = false; // aka Rhino quad/tri exported mesh - // std::ifstream file2(filename); - // std::string line2; - // while (std::getline(file2, line2)) - // { - // if (line2.find("element vertex") != std::string::npos) - // { - // isFixedLength = true; - // break; - // } - // } - // file2.close(); - // std::cout << "isFixedLength: " << isFixedLength << std::endl; - return mesh; } } // namespace diffCheck::io \ No newline at end of file diff --git a/src/diffCheck/log.cc b/src/diffCheck/log.cc new file mode 100644 index 00000000..283a9de5 --- /dev/null +++ b/src/diffCheck/log.cc @@ -0,0 +1,22 @@ +#include "diffCheck/log.hh" + +namespace diffCheck +{ + void Log::Init() + { + int argc = 1; + char* argv[] = { "loguru", nullptr }; + loguru::init(argc, argv); + loguru::add_file("diffCheckEvery.log", loguru::Truncate, loguru::Verbosity_MAX); + loguru::add_file("diffCheckErrors.log", loguru::Truncate, loguru::Verbosity_ERROR); + + loguru::g_stderr_verbosity = 1; + loguru::g_colorlogtostderr = true; + loguru::g_preamble = false; + } + + void Log::Shutdown() + { + loguru::shutdown(); + } +} \ No newline at end of file diff --git a/src/diffCheck/log.hh b/src/diffCheck/log.hh new file mode 100644 index 00000000..c3616104 --- /dev/null +++ b/src/diffCheck/log.hh @@ -0,0 +1,29 @@ +#pragma once + +#include + +namespace diffCheck +{ + class Log + { + public: + Log() { Init(); } + ~Log() { Shutdown(); } + + private: + void Init(); + void Shutdown(); + }; +} + +#ifndef SILENT_LOGGING + #define DIFFCHECK_INFO(message) LOG_F(INFO, message) + #define DIFFCHECK_WARN(message) LOG_F(WARNING, message) + #define DIFFCHECK_ERROR(message) LOG_F(ERROR, message) + #define DIFFCHECK_FATAL(message) LOG_F(FATAL, message) +#else + #define DIFFCHECK_INFO + #define DIFFCHECK_WARN + #define DIFFCHECK_ERROR + #define DIFFCHECK_FATAL +#endif \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index ec0023bc..bca9a8c4 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -14,13 +14,17 @@ int main() std::shared_ptr dfPointCloudPtr = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); - std::string pathCloud = R"(C:\Users\andre\Downloads\scan_data_normals.ply\scan_data_normals.ply)"; - std::string pathMesh = R"(F:\diffCheck\assets\dataset\mesh_fromRh_unfixedLength.ply)"; + // std::string pathCloud = R"(C:\Users\andre\Downloads\scan_data_normals.ply\scan_data_normals.ply)"; + // std::string pathMesh = R"(F:\diffCheck\assets\dataset\mesh_fromRh_unfixedLength.ply)"; // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - dfMeshPtr->LoadFromPLY(pathMesh); + + DIFFCHECK_INFO("test"); + DIFFCHECK_WARN("test"); + DIFFCHECK_ERROR("test"); + DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); @@ -32,5 +36,6 @@ int main() vis->AddMesh(dfMeshPtr); vis->Run(); + return 0; } \ No newline at end of file From 9c355e53864f507f666f2d7dea1cdc9875e19c09 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 18:28:40 +0100 Subject: [PATCH 090/141] FIX: updated planning --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index e52940c5..dbae83cc 100644 --- a/README.md +++ b/README.md @@ -37,8 +37,8 @@ gantt title diffCheck - backend dev excludes weekends - data i/o :active, dataio, 2024-03-15, 1w - global registration :glbreg, after dataio, 2w + 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 From 99f0332c5484dc0f82347562013cc55efb983df9 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 14:04:00 +0100 Subject: [PATCH 091/141] FIX: minor const for logger --- src/diffCheck.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 49ceec74..2e018738 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -5,7 +5,7 @@ // diffCheck includes #include "diffCheck/log.hh" -diffCheck::Log LOG = diffCheck::Log(); +const diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" From 535904a3400b36d06877858b46001d0cf7c3ad2c Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Tue, 2 Apr 2024 13:02:28 +0200 Subject: [PATCH 092/141] FIX: no logging to be pushed --- .gitignore | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 1eecb3c2..8b07029b 100644 --- a/.gitignore +++ b/.gitignore @@ -74,4 +74,7 @@ _deps ## General ####################################### # temp folder -temp/ \ No newline at end of file +temp/ + +# temporary logging file +*.log \ No newline at end of file From 1e07e4c9d0f1598f89bb7523f0cd4b2ccc091ec2 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:15:12 +0200 Subject: [PATCH 093/141] ADD: refinedRegistration files to create PR --- src/diffCheck/registration/refinedRegistration.cc | 1 + src/diffCheck/registration/refinedRegistration.hh | 0 2 files changed, 1 insertion(+) create mode 100644 src/diffCheck/registration/refinedRegistration.cc create mode 100644 src/diffCheck/registration/refinedRegistration.hh diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc new file mode 100644 index 00000000..8c788329 --- /dev/null +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -0,0 +1 @@ +#include "refinedRegistration.hh" diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh new file mode 100644 index 00000000..e69de29b From 79f4ddde9f457f29ddf4590ad19f073872a5d8a8 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 21:26:27 +0200 Subject: [PATCH 094/141] WIP: Open3d ICP added to registration class --- diffCheckErrors.log | 2 +- diffCheckEvery.log | Bin 455 -> 737 bytes src/diffCheck.hh | 3 ++- .../registration/refinedRegistration.cc | 14 ++++++++++++++ .../registration/refinedRegistration.hh | 15 +++++++++++++++ src/diffCheckApp.cc | 18 ++++++++++++++---- 6 files changed, 46 insertions(+), 6 deletions(-) diff --git a/diffCheckErrors.log b/diffCheckErrors.log index 092b5e99..f104f3b2 100644 --- a/diffCheckErrors.log +++ b/diffCheckErrors.log @@ -1,4 +1,4 @@ arguments: loguru -Current dir: F:\diffCheck +Current dir: C:\Users\localuser\diffCheck File verbosity level: -2 date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log index 20fc75ab3c002c6a823ebfd050def47301387949..db78b7876f71cf76d09f829391a126f331532452 100644 GIT binary patch literal 737 zcmeHEyJ`b55KJx5KTLNv@YC9 zv$L9Q87btX;G->Eq-YCsWndgDw5oeg#HsUft9_}kGp_I3fwrGgygE;qh&M60yoaZW zyuz~-MrXoY*^R#tSfG5(#1bFK1CurgdZZ_3u>Mh;x4v#r-i3L@bbu6Z(OMTQazu0T z@={&wAL|LtJ;rEAq1jb<@^*A}S;-tZU6nqpq?prDDh(x@xC@J=6nFpiM*^3VzQvEe E0ivLg=l}o! literal 455 zcmchS&rZWI42SQ1ir=k6q9sj-pt(+~goNM$fJ0c)EFyoZG%1?2hbL3n1Q(9@V#}64 z`{O|+D_xuzj8`e7Vv|D14G0|=diE;xFl_d6_fhoPNX#<4`$@+GjGU!m=nBE3#1c{4 za|x`F#-(wE7sP##T)=TFZ?wSM_r}jO source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index e69de29b..4bec4ced 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -0,0 +1,15 @@ +#pragma once +# include "diffCheck.hh" + +# include + +namespace diffCheck::registration +{ + class RefinedRegistration + { + public: + static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + }; +} \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index bca9a8c4..ad016d55 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -21,10 +21,20 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - DIFFCHECK_INFO("test"); - DIFFCHECK_WARN("test"); - DIFFCHECK_ERROR("test"); - DIFFCHECK_FATAL("test"); + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; + + dfMeshPtr->LoadFromPLY(pathMesh); + dfPointCloudPtr->LoadFromPLY(pathCloud); + + std::shared_ptr dfGroundTruth; + dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + + // DIFFCHECK_INFO("test"); + // DIFFCHECK_WARN("test"); + // DIFFCHECK_ERROR("test"); + // DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From 727c8ccf1a382363376f6003afff10673a3fda6f Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 22 Apr 2024 14:49:29 +0200 Subject: [PATCH 095/141] WIP: refined registrations implemented --- src/diffCheck/registration/refinedRegistration.cc | 11 +++++++++++ src/diffCheck/registration/refinedRegistration.hh | 3 +++ 2 files changed, 14 insertions(+) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0de763bb..0235a586 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -6,6 +6,17 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) { std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index 4bec4ced..edc5cb1e 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,5 +11,8 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); + static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file From 7da7b8b89d707e9019da95c6a9e5ec061296196d Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 15:32:06 +0100 Subject: [PATCH 096/141] WIP: stashing before refactoring cmake project --- cmake/Dockerfile | 34 ++++++++++++++++ cmake/install_open3d.bat | 86 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 120 insertions(+) create mode 100644 cmake/Dockerfile create mode 100644 cmake/install_open3d.bat diff --git a/cmake/Dockerfile b/cmake/Dockerfile new file mode 100644 index 00000000..4bbe0042 --- /dev/null +++ b/cmake/Dockerfile @@ -0,0 +1,34 @@ +# Use the latest Windows Server Core image with .NET Framework 4.8. +FROM mcr.microsoft.com/windows/servercore:ltsc2019 + +# Restore the default Windows shell for correct batch processing. +SHELL ["cmd", "/S", "/C"] + +# Download and install CMake +ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi +RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait + +# Download and install Git +ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe +RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait + +# Download and install vcpkg +RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg +RUN C:\\vcpkg\\bootstrap-vcpkg.bat + +# Install Open3D and other dependencies with vcpkg +RUN C:\\vcpkg\\vcpkg install open3d +RUN C:\\vcpkg\\vcpkg integrate install + +# Set up the working directory +WORKDIR C:/project + +# Clone the project +RUN git clone https://github.com/yourusername/yourproject.git . + +# Run the build script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] +RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] + +# Set the entrypoint to your application's main executable +ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat new file mode 100644 index 00000000..981feb33 --- /dev/null +++ b/cmake/install_open3d.bat @@ -0,0 +1,86 @@ +@echo off +setlocal + +:: run the following in a pop up window to avoid the console window and ask to ru n ass admin +@echo off +:: BatchGotAdmin +:------------------------------------- +REM --> Check for permissions +>nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" + +REM --> If error flag set, we do not have admin. +if '%errorlevel%' NEQ '0' ( + echo Requesting administrative privileges... + goto UACPrompt +) else ( goto gotAdmin ) + +:UACPrompt + echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" + echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs" + + "%temp%\getadmin.vbs" + exit /B + +:gotAdmin + if exist "%temp%\getadmin.vbs" ( del "%temp%\getadmin.vbs" ) + pushd "%CD%" + CD /D "%~dp0" +:-------------------------------------- + + + +:: Define the download URL and the target directory +set "url=https://github.com/isl-org/Open3D/releases/download/v0.18.0/open3d-devel-windows-amd64-0.18.0.zip" +set "targetDir=C:\Program Files\Open3Dtest" + +:: Create the if the directory does not exist +if not exist "%targetDir%" mkdir "%targetDir% + +:: check if the directory was created +if not exist "%targetDir%" ( + echo Failed to create the target directory. + exit /b 1 +) + +:: Download the file +echo Downloading Open3D... +curl -L -o "%targetDir%\open3d.zip" "%url%" + +:: Check if the file was downloaded +if not exist "%targetDir%\open3d.zip" ( + echo Failed to download Open3D. + exit /b 1 +) + +:: Extract the file +echo Extracting Open3D... +powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" + +@REM :: Delete the downloaded zip file +@REM del "%targetDir%\open3d.zip" + +@REM :: Change to the target directory +@REM cd /d "%targetDir%" + +@REM :: Run the cmake commands +@REM echo Building Open3D... +@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build +@REM if errorlevel 1 ( +@REM echo Failed to run cmake configuration command. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target ALL_BUILD +@REM if errorlevel 1 ( +@REM echo Failed to build ALL_BUILD. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target INSTALL +@REM if errorlevel 1 ( +@REM echo Failed to install. +@REM exit /b 1 +@REM ) + +@REM echo Done. +@REM endlocal \ No newline at end of file From 3e49bc93cd61a541b0ef9d33380394232c1b1874 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:26:55 +0100 Subject: [PATCH 097/141] WIP: testing docker windows --- .gitmodules | 9 --------- CMakeLists.txt | 30 ++++++++++++++++++++---------- cmake/Dockerfile => Dockerfile | 19 +++++-------------- deps/open3d | 1 - src/diffCheckApp.cc | 14 -------------- 5 files changed, 25 insertions(+), 48 deletions(-) rename cmake/Dockerfile => Dockerfile (65%) delete mode 160000 deps/open3d diff --git a/.gitmodules b/.gitmodules index d1521ec4..e74877f6 100644 --- a/.gitmodules +++ b/.gitmodules @@ -5,12 +5,3 @@ [submodule "deps/eigen"] path = deps/eigen url = https://gitlab.com/libeigen/eigen.git -[submodule "deps/open3d"] - path = deps/open3d - url = https://github.com/diffCheckOrg/submodule-open3d.git -[submodule "deps/boost"] - path = deps/boost - url = https://github.com/diffCheckOrg/submodule-boost.git -[submodule "deps/loguru"] - path = deps/loguru - url = https://github.com/emilk/loguru.git diff --git a/CMakeLists.txt b/CMakeLists.txt index 3033fdb5..69a5c4cc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,7 +62,17 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (pre-built binaries) --------------------------------------------- +# Open3D (pre-built binaries) ----------------------------------------------------- +# The options need to be the same as Open3D's default +# If Open3D is configured and built with custom options, you'll also need to +# specify the same custom options. +option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) +if(STATIC_WINDOWS_RUNTIME) + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +else() + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") +endif() + download_submodule_project(open3d) set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) @@ -87,17 +97,17 @@ if(WIN32) endif() endif() -# Boost (header only) ----------------------------------------------------- -download_submodule_project(boost) -target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) +# # Boost (from system) ----------------------------------------------------- +# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download +# find_package(Boost REQUIRED) + +# # print boost include dir +# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -# CGAL (header-only) ------------------------------------------------------ -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# loguru (header-only) ---------------------------------------------------- -download_submodule_project(loguru) -add_subdirectory(deps/loguru) -target_link_libraries(${SHARED_LIB_NAME} PUBLIC loguru::loguru) +# # CGAL (header-only) ------------------------------------------------------ +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/cmake/Dockerfile b/Dockerfile similarity index 65% rename from cmake/Dockerfile rename to Dockerfile index 4bbe0042..34b2c6f8 100644 --- a/cmake/Dockerfile +++ b/Dockerfile @@ -12,23 +12,14 @@ RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait -# Download and install vcpkg -RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg -RUN C:\\vcpkg\\bootstrap-vcpkg.bat - -# Install Open3D and other dependencies with vcpkg -RUN C:\\vcpkg\\vcpkg install open3d -RUN C:\\vcpkg\\vcpkg integrate install - # Set up the working directory WORKDIR C:/project -# Clone the project -RUN git clone https://github.com/yourusername/yourproject.git . +# make the code available in the container +COPY . . + +# Run the cmake/config.bat script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] # Run the build script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] - -# Set the entrypoint to your application's main executable -ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/deps/open3d b/deps/open3d deleted file mode 160000 index 7f83ddfc..00000000 --- a/deps/open3d +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 7f83ddfcbbb512824f358c365a3c62f6cd246f87 diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index ad016d55..a2b3aee6 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -20,21 +20,7 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - - std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; - // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; - dfMeshPtr->LoadFromPLY(pathMesh); - dfPointCloudPtr->LoadFromPLY(pathCloud); - - std::shared_ptr dfGroundTruth; - dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); - - // DIFFCHECK_INFO("test"); - // DIFFCHECK_WARN("test"); - // DIFFCHECK_ERROR("test"); - // DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From 4211a03d7ac24d1561b83dd267ab084f479268df Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:48:38 +0100 Subject: [PATCH 098/141] FIX: udpated correct istructions README --- CMakeLists.txt | 16 ++++---- Dockerfile | 25 ------------ README.md | 4 +- cmake/install_open3d.bat | 86 ---------------------------------------- deps/boost | 1 - src/diffCheck.hh | 1 + 6 files changed, 11 insertions(+), 122 deletions(-) delete mode 100644 Dockerfile delete mode 100644 cmake/install_open3d.bat delete mode 160000 deps/boost diff --git a/CMakeLists.txt b/CMakeLists.txt index 69a5c4cc..65d62459 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -97,17 +97,17 @@ if(WIN32) endif() endif() -# # Boost (from system) ----------------------------------------------------- -# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download -# find_package(Boost REQUIRED) +# Boost (header only) ----------------------------------------------------- +download_submodule_project(boost) +target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# # print boost include dir -# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") +# print boost include dir +message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# # CGAL (header-only) ------------------------------------------------------ -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# CGAL (header-only) ------------------------------------------------------ +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index 34b2c6f8..00000000 --- a/Dockerfile +++ /dev/null @@ -1,25 +0,0 @@ -# Use the latest Windows Server Core image with .NET Framework 4.8. -FROM mcr.microsoft.com/windows/servercore:ltsc2019 - -# Restore the default Windows shell for correct batch processing. -SHELL ["cmd", "/S", "/C"] - -# Download and install CMake -ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi -RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait - -# Download and install Git -ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe -RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait - -# Set up the working directory -WORKDIR C:/project - -# make the code available in the container -COPY . . - -# Run the cmake/config.bat script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] - -# Run the build script -RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] diff --git a/README.md b/README.md index dbae83cc..9e743d1c 100644 --- a/README.md +++ b/README.md @@ -47,10 +47,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-open3d.git)) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) - `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-boost.git)) +- `Boost` for general utilities as pre-build binaries ## How to build c++ project To build and test the project, follow the following steps: diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat deleted file mode 100644 index 981feb33..00000000 --- a/cmake/install_open3d.bat +++ /dev/null @@ -1,86 +0,0 @@ -@echo off -setlocal - -:: run the following in a pop up window to avoid the console window and ask to ru n ass admin -@echo off -:: BatchGotAdmin -:------------------------------------- -REM --> Check for permissions ->nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" - -REM --> If error flag set, we do not have admin. -if '%errorlevel%' NEQ '0' ( - echo Requesting administrative privileges... - goto UACPrompt -) else ( goto gotAdmin ) - -:UACPrompt - echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" - echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs" - - "%temp%\getadmin.vbs" - exit /B - -:gotAdmin - if exist "%temp%\getadmin.vbs" ( del "%temp%\getadmin.vbs" ) - pushd "%CD%" - CD /D "%~dp0" -:-------------------------------------- - - - -:: Define the download URL and the target directory -set "url=https://github.com/isl-org/Open3D/releases/download/v0.18.0/open3d-devel-windows-amd64-0.18.0.zip" -set "targetDir=C:\Program Files\Open3Dtest" - -:: Create the if the directory does not exist -if not exist "%targetDir%" mkdir "%targetDir% - -:: check if the directory was created -if not exist "%targetDir%" ( - echo Failed to create the target directory. - exit /b 1 -) - -:: Download the file -echo Downloading Open3D... -curl -L -o "%targetDir%\open3d.zip" "%url%" - -:: Check if the file was downloaded -if not exist "%targetDir%\open3d.zip" ( - echo Failed to download Open3D. - exit /b 1 -) - -:: Extract the file -echo Extracting Open3D... -powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" - -@REM :: Delete the downloaded zip file -@REM del "%targetDir%\open3d.zip" - -@REM :: Change to the target directory -@REM cd /d "%targetDir%" - -@REM :: Run the cmake commands -@REM echo Building Open3D... -@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build -@REM if errorlevel 1 ( -@REM echo Failed to run cmake configuration command. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target ALL_BUILD -@REM if errorlevel 1 ( -@REM echo Failed to build ALL_BUILD. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target INSTALL -@REM if errorlevel 1 ( -@REM echo Failed to install. -@REM exit /b 1 -@REM ) - -@REM echo Done. -@REM endlocal \ No newline at end of file diff --git a/deps/boost b/deps/boost deleted file mode 160000 index ee2a0a55..00000000 --- a/deps/boost +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ee2a0a555b6fe33458ae19bfa1e193d8e67bb6e9 diff --git a/src/diffCheck.hh b/src/diffCheck.hh index fb645b6d..ccee8dbc 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,5 +1,6 @@ #pragma once + #include #include From 8c59e130dad5e64619b71fb799128d0e6bf3470c Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:50:21 +0100 Subject: [PATCH 099/141] FIX: udpated correct istructions README x2 --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 9e743d1c..dbae83cc 100644 --- a/README.md +++ b/README.md @@ -47,10 +47,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-open3d.git)) - `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities as pre-build binaries +- `Boost` for general utilities as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-boost.git)) ## How to build c++ project To build and test the project, follow the following steps: From 1537aafbac60a07be10823dca8900caf79d6410f Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 12:56:26 +0100 Subject: [PATCH 100/141] CAP: added logging --- .gitmodules | 3 +++ CMakeLists.txt | 22 ++++++---------------- diffCheckErrors.log | 2 +- diffCheckEvery.log | Bin 737 -> 0 bytes src/diffCheck.hh | 4 ++-- src/diffCheckApp.cc | 6 +++++- 6 files changed, 17 insertions(+), 20 deletions(-) delete mode 100644 diffCheckEvery.log diff --git a/.gitmodules b/.gitmodules index e74877f6..64917aff 100644 --- a/.gitmodules +++ b/.gitmodules @@ -5,3 +5,6 @@ [submodule "deps/eigen"] path = deps/eigen url = https://gitlab.com/libeigen/eigen.git +[submodule "deps/loguru"] + path = deps/loguru + url = https://github.com/emilk/loguru.git diff --git a/CMakeLists.txt b/CMakeLists.txt index 65d62459..3033fdb5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,17 +62,7 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (pre-built binaries) ----------------------------------------------------- -# The options need to be the same as Open3D's default -# If Open3D is configured and built with custom options, you'll also need to -# specify the same custom options. -option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) -if(STATIC_WINDOWS_RUNTIME) - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") -else() - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") -endif() - +# Open3D (pre-built binaries) --------------------------------------------- download_submodule_project(open3d) set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) @@ -101,14 +91,14 @@ endif() download_submodule_project(boost) target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# print boost include dir -message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") - -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) - # CGAL (header-only) ------------------------------------------------------ target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# loguru (header-only) ---------------------------------------------------- +download_submodule_project(loguru) +add_subdirectory(deps/loguru) +target_link_libraries(${SHARED_LIB_NAME} PUBLIC loguru::loguru) + #-------------------------------------------------------------------------- # executable for prototyping #-------------------------------------------------------------------------- diff --git a/diffCheckErrors.log b/diffCheckErrors.log index f104f3b2..092b5e99 100644 --- a/diffCheckErrors.log +++ b/diffCheckErrors.log @@ -1,4 +1,4 @@ arguments: loguru -Current dir: C:\Users\localuser\diffCheck +Current dir: F:\diffCheck File verbosity level: -2 date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log deleted file mode 100644 index db78b7876f71cf76d09f829391a126f331532452..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 737 zcmeHEyJ`b55KJx5KTLNv@YC9 zv$L9Q87btX;G->Eq-YCsWndgDw5oeg#HsUft9_}kGp_I3fwrGgygE;qh&M60yoaZW zyuz~-MrXoY*^R#tSfG5(#1bFK1CurgdZZ_3u>Mh;x4v#r-i3L@bbu6Z(OMTQazu0T z@={&wAL|LtJ;rEAq1jb<@^*A}S;-tZU6nqpq?prDDh(x@xC@J=6nFpiM*^3VzQvEe E0ivLg=l}o! diff --git a/src/diffCheck.hh b/src/diffCheck.hh index ccee8dbc..399469ca 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,12 +1,12 @@ #pragma once - #include #include +#include // diffCheck includes #include "diffCheck/log.hh" -const diffCheck::Log LOG = diffCheck::Log(); +diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index a2b3aee6..bca9a8c4 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -20,7 +20,11 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - dfMeshPtr->LoadFromPLY(pathMesh); + + DIFFCHECK_INFO("test"); + DIFFCHECK_WARN("test"); + DIFFCHECK_ERROR("test"); + DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From b7346c8739f0c2ef2eeaedca3d62c031c2bf3dcb Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 14:04:00 +0100 Subject: [PATCH 101/141] FIX: minor const for logger --- src/diffCheck.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 399469ca..b3a4ec25 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -6,7 +6,7 @@ // diffCheck includes #include "diffCheck/log.hh" -diffCheck::Log LOG = diffCheck::Log(); +const diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" From d56f8c4e92cee23e659c35fc7bd50acfa94c8c0b Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:15:12 +0200 Subject: [PATCH 102/141] ADD: refinedRegistration files to create PR --- .../registration/refinedRegistration.cc | 25 ------------------- 1 file changed, 25 deletions(-) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0235a586..8c788329 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -1,26 +1 @@ #include "refinedRegistration.hh" - - -namespace diffCheck::registration -{ - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; - } - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); - return result; - } -} \ No newline at end of file From 3115296e7636bc9110d628ef9890f627e1eaca2f Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 21:26:27 +0200 Subject: [PATCH 103/141] WIP: Open3d ICP added to registration class --- diffCheckErrors.log | 2 +- .../registration/refinedRegistration.cc | 14 ++++++++++++++ .../registration/refinedRegistration.hh | 3 --- src/diffCheckApp.cc | 18 ++++++++++++++---- 4 files changed, 29 insertions(+), 8 deletions(-) diff --git a/diffCheckErrors.log b/diffCheckErrors.log index 092b5e99..f104f3b2 100644 --- a/diffCheckErrors.log +++ b/diffCheckErrors.log @@ -1,4 +1,4 @@ arguments: loguru -Current dir: F:\diffCheck +Current dir: C:\Users\localuser\diffCheck File verbosity level: -2 date time ( uptime ) [ thread name/id ] file:line v| diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 8c788329..0de763bb 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -1 +1,15 @@ #include "refinedRegistration.hh" + + +namespace diffCheck::registration +{ + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index edc5cb1e..4bec4ced 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,8 +11,5 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); - static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index bca9a8c4..ad016d55 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -21,10 +21,20 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - DIFFCHECK_INFO("test"); - DIFFCHECK_WARN("test"); - DIFFCHECK_ERROR("test"); - DIFFCHECK_FATAL("test"); + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; + + dfMeshPtr->LoadFromPLY(pathMesh); + dfPointCloudPtr->LoadFromPLY(pathCloud); + + std::shared_ptr dfGroundTruth; + dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + + // DIFFCHECK_INFO("test"); + // DIFFCHECK_WARN("test"); + // DIFFCHECK_ERROR("test"); + // DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From e5dcdf51dc81103e51610eb2e00f37ddf373fa77 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 22 Apr 2024 14:49:29 +0200 Subject: [PATCH 104/141] WIP: refined registrations implemented --- src/diffCheck/registration/refinedRegistration.cc | 11 +++++++++++ src/diffCheck/registration/refinedRegistration.hh | 3 +++ 2 files changed, 14 insertions(+) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0de763bb..0235a586 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -6,6 +6,17 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) { std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index 4bec4ced..edc5cb1e 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,5 +11,8 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); + static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file From f7dcbf73dd65ed957fcaff6978c1122bad94f55b Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 10:04:57 +0200 Subject: [PATCH 105/141] FIX: open3d and boost submodules erronously deleted: re-added using local git directory --- .gitmodules | 6 ++++++ deps/boost | 1 + deps/open3d | 1 + 3 files changed, 8 insertions(+) create mode 160000 deps/boost create mode 160000 deps/open3d diff --git a/.gitmodules b/.gitmodules index 64917aff..4614a235 100644 --- a/.gitmodules +++ b/.gitmodules @@ -8,3 +8,9 @@ [submodule "deps/loguru"] path = deps/loguru url = https://github.com/emilk/loguru.git +[submodule "deps/boost"] + path = deps/boost + url = https://github.com/diffCheckOrg/submodule-boost.git +[submodule "deps/open3d"] + path = deps/open3d + url = https://github.com/diffCheckOrg/submodule-open3d.git diff --git a/deps/boost b/deps/boost new file mode 160000 index 00000000..ee2a0a55 --- /dev/null +++ b/deps/boost @@ -0,0 +1 @@ +Subproject commit ee2a0a555b6fe33458ae19bfa1e193d8e67bb6e9 diff --git a/deps/open3d b/deps/open3d new file mode 160000 index 00000000..7f83ddfc --- /dev/null +++ b/deps/open3d @@ -0,0 +1 @@ +Subproject commit 7f83ddfcbbb512824f358c365a3c62f6cd246f87 From 9d957a5dddf7736bb854859f78758c796d2d7117 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 10:21:37 +0200 Subject: [PATCH 106/141] WIP: change file name to DFRefinedRegistration and add documentation --- .../registration/DFRefinedRegistration.cc | 32 ++++++++++++++++ .../registration/DFRefinedRegistration.hh | 37 +++++++++++++++++++ .../registration/refinedRegistration.cc | 26 ------------- .../registration/refinedRegistration.hh | 18 --------- 4 files changed, 69 insertions(+), 44 deletions(-) create mode 100644 src/diffCheck/registration/DFRefinedRegistration.cc create mode 100644 src/diffCheck/registration/DFRefinedRegistration.hh delete mode 100644 src/diffCheck/registration/refinedRegistration.cc delete mode 100644 src/diffCheck/registration/refinedRegistration.hh diff --git a/src/diffCheck/registration/DFRefinedRegistration.cc b/src/diffCheck/registration/DFRefinedRegistration.cc new file mode 100644 index 00000000..a619e571 --- /dev/null +++ b/src/diffCheck/registration/DFRefinedRegistration.cc @@ -0,0 +1,32 @@ +#include "refinedRegistration.hh" + + +namespace diffCheck::registration +{ + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/DFRefinedRegistration.hh b/src/diffCheck/registration/DFRefinedRegistration.hh new file mode 100644 index 00000000..c59561cc --- /dev/null +++ b/src/diffCheck/registration/DFRefinedRegistration.hh @@ -0,0 +1,37 @@ +#pragma once +# include "diffCheck.hh" + +# include + +namespace diffCheck::registration +{ + class RefinedRegistration + { + public: ///< open3d registration methods + /** + * @brief Perform ICP registration using Open3D + * + * @param source DFPointCloud source point cloud + * @param target DFPointCloud Target point cloud + * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @return diffCheck::transformation::DFTransformation + */ + static diffCheck::transformation::DFTransformation O3DICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + + /** + * @brief Perform Generalized ICP registration using Open3D + * + * @param source DFPointCloud source point cloud + * @param target DFPointCloud Target point cloud + * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @return diffCheck::transformation::DFTransformation + */ + static diffCheck::transformation::DFTransformation O3DGeneralizedICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + }; +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc deleted file mode 100644 index 0235a586..00000000 --- a/src/diffCheck/registration/refinedRegistration.cc +++ /dev/null @@ -1,26 +0,0 @@ -#include "refinedRegistration.hh" - - -namespace diffCheck::registration -{ - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; - } - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); - return result; - } -} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh deleted file mode 100644 index edc5cb1e..00000000 --- a/src/diffCheck/registration/refinedRegistration.hh +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once -# include "diffCheck.hh" - -# include - -namespace diffCheck::registration -{ - class RefinedRegistration - { - public: - static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); - static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); - }; -} \ No newline at end of file From f458659ce598d40f0303797dacf397d40327f732 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 15:32:06 +0100 Subject: [PATCH 107/141] WIP: stashing before refactoring cmake project --- cmake/Dockerfile | 34 ++++++++++++++++ cmake/install_open3d.bat | 86 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 120 insertions(+) create mode 100644 cmake/Dockerfile create mode 100644 cmake/install_open3d.bat diff --git a/cmake/Dockerfile b/cmake/Dockerfile new file mode 100644 index 00000000..4bbe0042 --- /dev/null +++ b/cmake/Dockerfile @@ -0,0 +1,34 @@ +# Use the latest Windows Server Core image with .NET Framework 4.8. +FROM mcr.microsoft.com/windows/servercore:ltsc2019 + +# Restore the default Windows shell for correct batch processing. +SHELL ["cmd", "/S", "/C"] + +# Download and install CMake +ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi +RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait + +# Download and install Git +ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe +RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait + +# Download and install vcpkg +RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg +RUN C:\\vcpkg\\bootstrap-vcpkg.bat + +# Install Open3D and other dependencies with vcpkg +RUN C:\\vcpkg\\vcpkg install open3d +RUN C:\\vcpkg\\vcpkg integrate install + +# Set up the working directory +WORKDIR C:/project + +# Clone the project +RUN git clone https://github.com/yourusername/yourproject.git . + +# Run the build script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] +RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] + +# Set the entrypoint to your application's main executable +ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat new file mode 100644 index 00000000..f10ca4af --- /dev/null +++ b/cmake/install_open3d.bat @@ -0,0 +1,86 @@ +@echo off +setlocal + +:: run the following in a pop up window to avoid the console window and ask to ru n ass admin +@echo off +:: BatchGotAdmin +:------------------------------------- +REM --> Check for permissions +>nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" + +REM --> If error flag set, we do not have admin. +if '%errorlevel%' NEQ '0' ( + echo Requesting administrative privileges... + goto UACPrompt +) else ( goto gotAdmin ) + +:UACPrompt + echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" + echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs" + + "%temp%\getadmin.vbs" + exit /B + +:gotAdmin + if exist "%temp%\getadmin.vbs" ( del "%temp%\getadmin.vbs" ) + pushd "%CD%" + CD /D "%~dp0" +:-------------------------------------- + + + +:: Define the download URL and the target directory +set "url=https://github.com/isl-org/Open3D/releases/download/v0.18.0/open3d-devel-windows-amd64-0.18.0.zip" +set "targetDir=C:\Program Files\Open3Dtest" + +:: Create the if the directory does not exist +if not exist "%targetDir%" mkdir "%targetDir% + +:: check if the directory was created +if not exist "%targetDir%" ( + echo Failed to create the target directory. + exit /b 1 +) + +:: Download the file +echo Downloading Open3D... +curl -L -o "%targetDir%\open3d.zip" "%url%" + +:: Check if the file was downloaded +if not exist "%targetDir%\open3d.zip" ( + echo Failed to download Open3D. + exit /b 1 +) + +:: Extract the file +echo Extracting Open3D... +powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" + +@REM :: Delete the downloaded zip file +@REM del "%targetDir%\open3d.zip" + +@REM :: Change to the target directory +@REM cd /d "%targetDir%" + +@REM :: Run the cmake commands +@REM echo Building Open3D... +@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build +@REM if errorlevel 1 ( +@REM echo Failed to run cmake configuration command. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target ALL_BUILD +@REM if errorlevel 1 ( +@REM echo Failed to build ALL_BUILD. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target INSTALL +@REM if errorlevel 1 ( +@REM echo Failed to install. +@REM exit /b 1 +@REM ) + +@REM echo Done. +@REM endlocal From ba27e3eb9cd5415bea10dc676666c7a6d3567806 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:26:55 +0100 Subject: [PATCH 108/141] WIP: testing docker windows --- .gitmodules | 9 ----- CMakeLists.txt | 30 ++++++++++----- cmake/Dockerfile => Dockerfile | 19 +++------- deps/open3d | 1 - src/diffCheckApp.cc | 67 +++------------------------------- 5 files changed, 31 insertions(+), 95 deletions(-) rename cmake/Dockerfile => Dockerfile (65%) delete mode 160000 deps/open3d diff --git a/.gitmodules b/.gitmodules index d1521ec4..e74877f6 100644 --- a/.gitmodules +++ b/.gitmodules @@ -5,12 +5,3 @@ [submodule "deps/eigen"] path = deps/eigen url = https://gitlab.com/libeigen/eigen.git -[submodule "deps/open3d"] - path = deps/open3d - url = https://github.com/diffCheckOrg/submodule-open3d.git -[submodule "deps/boost"] - path = deps/boost - url = https://github.com/diffCheckOrg/submodule-boost.git -[submodule "deps/loguru"] - path = deps/loguru - url = https://github.com/emilk/loguru.git diff --git a/CMakeLists.txt b/CMakeLists.txt index 8969f917..f3b4aca9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -61,7 +61,17 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (pre-built binaries) --------------------------------------------- +# Open3D (pre-built binaries) ----------------------------------------------------- +# The options need to be the same as Open3D's default +# If Open3D is configured and built with custom options, you'll also need to +# specify the same custom options. +option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) +if(STATIC_WINDOWS_RUNTIME) + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +else() + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") +endif() + download_submodule_project(open3d) set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) @@ -86,17 +96,17 @@ if(WIN32) endif() endif() -# Boost (header only) ----------------------------------------------------- -download_submodule_project(boost) -target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) +# # Boost (from system) ----------------------------------------------------- +# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download +# find_package(Boost REQUIRED) + +# # print boost include dir +# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -# CGAL (header-only) ------------------------------------------------------ -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# loguru (header-only) ---------------------------------------------------- -download_submodule_project(loguru) -add_subdirectory(deps/loguru) -target_link_libraries(${SHARED_LIB_NAME} PUBLIC loguru::loguru) +# # CGAL (header-only) ------------------------------------------------------ +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/cmake/Dockerfile b/Dockerfile similarity index 65% rename from cmake/Dockerfile rename to Dockerfile index 4bbe0042..34b2c6f8 100644 --- a/cmake/Dockerfile +++ b/Dockerfile @@ -12,23 +12,14 @@ RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait -# Download and install vcpkg -RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg -RUN C:\\vcpkg\\bootstrap-vcpkg.bat - -# Install Open3D and other dependencies with vcpkg -RUN C:\\vcpkg\\vcpkg install open3d -RUN C:\\vcpkg\\vcpkg integrate install - # Set up the working directory WORKDIR C:/project -# Clone the project -RUN git clone https://github.com/yourusername/yourproject.git . +# make the code available in the container +COPY . . + +# Run the cmake/config.bat script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] # Run the build script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] - -# Set the entrypoint to your application's main executable -ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/deps/open3d b/deps/open3d deleted file mode 160000 index 7f83ddfc..00000000 --- a/deps/open3d +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 7f83ddfcbbb512824f358c365a3c62f6cd246f87 diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 24ba48c3..e1d564c4 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -22,72 +22,17 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - - DIFFCHECK_INFO("test"); - DIFFCHECK_WARN("test"); - DIFFCHECK_ERROR("test"); - DIFFCHECK_FATAL("test"); - std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; - std::string pathCloud_1 = R"(C:\Users\localuser\Downloads\part_1_module.ply)"; - std::string pathCloud_2 = R"(C:\Users\localuser\Downloads\part_2_module.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\04_mesh.ply)"; - dfMeshPtr->LoadFromPLY(pathMesh); - dfPointCloudPtr->LoadFromPLY(pathCloud); - dfPointCloudPtr_1->LoadFromPLY(pathCloud_1); - dfPointCloudPtr_2->LoadFromPLY(pathCloud_2); - dfPointCloudPtrGroundTruth->LoadFromPLY(pathCloud); - - // add noise to dfPointCloudPtr - std::vector boundingBoxPoints = dfPointCloudPtr->ComputeBoundingBox(); - double meanInterval = (boundingBoxPoints[0] - boundingBoxPoints[1]).norm(); - for (int i = 0; i < dfPointCloudPtr->Points.size(); i++) - { - dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.002 * meanInterval; - } - - std::shared_ptr pcd_1 = dfPointCloudPtr->Cvt2O3DPointCloud(); - if (pcd_1->normals_.size() > 0) - { - pcd_1->normals_.clear(); - } - dfPointCloudPtrWithoutNormals->Cvt2DFPointCloud(pcd_1); - - // populate the mesh with points and store it in dfPointCloudPtrGroundTruthFromMesh - std::shared_ptr pcd_2 = dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(50000); - dfPointCloudPtrGroundTruthFromMesh->Cvt2DFPointCloud(pcd_2); - - // create a rigid rotation matrix - Eigen::Matrix4d T = Eigen::Matrix4d::Identity(); - T.block<3, 3>(0, 0) = Eigen::AngleAxisd(1.57, Eigen::Vector3d::UnitX()).toRotationMatrix(); - T(0, 3) = 50; - T(1, 3) = -100; - T(2, 3) = 100; - dfPointCloudPtrWithoutNormals->ApplyTransformation(diffCheck::transformation::DFTransformation(T)); - // create a copy of the point cloud so we can test both global registrations - std::shared_ptr dfPointCloudPtrCopy = std::make_shared(*dfPointCloudPtrWithoutNormals); - // test global registrations Fast and RANSAC-based - std::vector registrationResults; - diffCheck::transformation::DFTransformation transformationA = - diffCheck::registrations::DFGlobalRegistrations::O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtr_1, dfPointCloudPtr_2); - std::cout << "Fast transformation: " << transformationA.TransformationMatrix << std::endl; - //dfPointCloudPtr_1->ApplyTransformation(transformationA); - registrationResults.push_back(transformationA); - diffCheck::transformation::DFTransformation transformationB = - diffCheck::registrations::DFGlobalRegistrations::O3DRansacOnFeatureMatching(dfPointCloudPtr_1, dfPointCloudPtr_2); - std::cout << "Ransac transformation: " << transformationB.TransformationMatrix << std::endl; - dfPointCloudPtr_1->ApplyTransformation(transformationB); - registrationResults.push_back(transformationB); + dfMeshPtr->Cvt2DFMesh(mesh); - // visualize cloud - std::shared_ptr visualizer = std::make_shared(); - visualizer->AddPointCloud(dfPointCloudPtr_1); - visualizer->AddPointCloud(dfPointCloudPtr_2); - // visualizer->AddMesh(dfMeshPtr); - visualizer->Run(); + // dfPointCloudPtr->LoadFromPLY(pathCloud); + std::shared_ptr vis = std::make_shared(); + // vis->AddPointCloud(dfPointCloudPtr); + vis->AddMesh(dfMeshPtr); + vis->Run(); return 0; } \ No newline at end of file From 05d8f515e8ad97b2c5cd5def6c8c6a151fa848b7 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:48:38 +0100 Subject: [PATCH 109/141] FIX: udpated correct istructions README --- CMakeLists.txt | 16 ++++---- Dockerfile | 25 ------------ README.md | 4 +- cmake/install_open3d.bat | 86 ---------------------------------------- deps/boost | 1 - src/diffCheck.hh | 1 + 6 files changed, 11 insertions(+), 122 deletions(-) delete mode 100644 Dockerfile delete mode 100644 cmake/install_open3d.bat delete mode 160000 deps/boost diff --git a/CMakeLists.txt b/CMakeLists.txt index f3b4aca9..b1a5e9b7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -96,17 +96,17 @@ if(WIN32) endif() endif() -# # Boost (from system) ----------------------------------------------------- -# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download -# find_package(Boost REQUIRED) +# Boost (header only) ----------------------------------------------------- +download_submodule_project(boost) +target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# # print boost include dir -# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") +# print boost include dir +message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# # CGAL (header-only) ------------------------------------------------------ -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# CGAL (header-only) ------------------------------------------------------ +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index 34b2c6f8..00000000 --- a/Dockerfile +++ /dev/null @@ -1,25 +0,0 @@ -# Use the latest Windows Server Core image with .NET Framework 4.8. -FROM mcr.microsoft.com/windows/servercore:ltsc2019 - -# Restore the default Windows shell for correct batch processing. -SHELL ["cmd", "/S", "/C"] - -# Download and install CMake -ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi -RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait - -# Download and install Git -ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe -RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait - -# Set up the working directory -WORKDIR C:/project - -# make the code available in the container -COPY . . - -# Run the cmake/config.bat script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] - -# Run the build script -RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] diff --git a/README.md b/README.md index 62e95560..c2c7ee37 100644 --- a/README.md +++ b/README.md @@ -50,10 +50,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-open3d.git)) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) - `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-boost.git)) +- `Boost` for general utilities as pre-build binaries ## How to build c++ project To build and test the project, follow the following steps: diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat deleted file mode 100644 index f10ca4af..00000000 --- a/cmake/install_open3d.bat +++ /dev/null @@ -1,86 +0,0 @@ -@echo off -setlocal - -:: run the following in a pop up window to avoid the console window and ask to ru n ass admin -@echo off -:: BatchGotAdmin -:------------------------------------- -REM --> Check for permissions ->nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" - -REM --> If error flag set, we do not have admin. -if '%errorlevel%' NEQ '0' ( - echo Requesting administrative privileges... - goto UACPrompt -) else ( goto gotAdmin ) - -:UACPrompt - echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" - echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs" - - "%temp%\getadmin.vbs" - exit /B - -:gotAdmin - if exist "%temp%\getadmin.vbs" ( del "%temp%\getadmin.vbs" ) - pushd "%CD%" - CD /D "%~dp0" -:-------------------------------------- - - - -:: Define the download URL and the target directory -set "url=https://github.com/isl-org/Open3D/releases/download/v0.18.0/open3d-devel-windows-amd64-0.18.0.zip" -set "targetDir=C:\Program Files\Open3Dtest" - -:: Create the if the directory does not exist -if not exist "%targetDir%" mkdir "%targetDir% - -:: check if the directory was created -if not exist "%targetDir%" ( - echo Failed to create the target directory. - exit /b 1 -) - -:: Download the file -echo Downloading Open3D... -curl -L -o "%targetDir%\open3d.zip" "%url%" - -:: Check if the file was downloaded -if not exist "%targetDir%\open3d.zip" ( - echo Failed to download Open3D. - exit /b 1 -) - -:: Extract the file -echo Extracting Open3D... -powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" - -@REM :: Delete the downloaded zip file -@REM del "%targetDir%\open3d.zip" - -@REM :: Change to the target directory -@REM cd /d "%targetDir%" - -@REM :: Run the cmake commands -@REM echo Building Open3D... -@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build -@REM if errorlevel 1 ( -@REM echo Failed to run cmake configuration command. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target ALL_BUILD -@REM if errorlevel 1 ( -@REM echo Failed to build ALL_BUILD. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target INSTALL -@REM if errorlevel 1 ( -@REM echo Failed to install. -@REM exit /b 1 -@REM ) - -@REM echo Done. -@REM endlocal diff --git a/deps/boost b/deps/boost deleted file mode 160000 index ee2a0a55..00000000 --- a/deps/boost +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ee2a0a555b6fe33458ae19bfa1e193d8e67bb6e9 diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 891e76fa..2e421aba 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,5 +1,6 @@ #pragma once + #include #include From e5923e8e6feacc588fcdf13d834b11334074a02c Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:50:21 +0100 Subject: [PATCH 110/141] FIX: udpated correct istructions README x2 --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c2c7ee37..62e95560 100644 --- a/README.md +++ b/README.md @@ -50,10 +50,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-open3d.git)) - `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities as pre-build binaries +- `Boost` for general utilities as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-boost.git)) ## How to build c++ project To build and test the project, follow the following steps: From 9969a8a043f599cf947f4eb403d125bbd36eac31 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 12:56:26 +0100 Subject: [PATCH 111/141] CAP: added logging --- .gitmodules | 3 +++ CMakeLists.txt | 29 +++++++++++++---------------- diffCheckErrors.log | 4 ++++ diffCheckEvery.log | 6 ++++++ src/diffCheck.hh | 4 ++-- src/diffCheckApp.cc | 7 ++++++- 6 files changed, 34 insertions(+), 19 deletions(-) create mode 100644 diffCheckErrors.log create mode 100644 diffCheckEvery.log diff --git a/.gitmodules b/.gitmodules index e74877f6..64917aff 100644 --- a/.gitmodules +++ b/.gitmodules @@ -5,3 +5,6 @@ [submodule "deps/eigen"] path = deps/eigen url = https://gitlab.com/libeigen/eigen.git +[submodule "deps/loguru"] + path = deps/loguru + url = https://github.com/emilk/loguru.git diff --git a/CMakeLists.txt b/CMakeLists.txt index b1a5e9b7..d3d19170 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,6 +23,13 @@ if(SILENT_LOGGING) target_compile_definitions(${PROJECT_NAME} PRIVATE SILENT_LOGGING=true) endif() +#-------------------------------------------------------------------------- +# pre-compiled definitions +#-------------------------------------------------------------------------- +if(SILENT_LOGGING) + target_compile_definitions(${PROJECT_NAME} PRIVATE SILENT_LOGGING=true) +endif() + #-------------------------------------------------------------------------- # diffCheck dynamic lib #-------------------------------------------------------------------------- @@ -61,17 +68,7 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (pre-built binaries) ----------------------------------------------------- -# The options need to be the same as Open3D's default -# If Open3D is configured and built with custom options, you'll also need to -# specify the same custom options. -option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) -if(STATIC_WINDOWS_RUNTIME) - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") -else() - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") -endif() - +# Open3D (pre-built binaries) --------------------------------------------- download_submodule_project(open3d) set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) @@ -100,14 +97,14 @@ endif() download_submodule_project(boost) target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# print boost include dir -message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") - -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) - # CGAL (header-only) ------------------------------------------------------ target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# loguru (header-only) ---------------------------------------------------- +download_submodule_project(loguru) +add_subdirectory(deps/loguru) +target_link_libraries(${SHARED_LIB_NAME} PUBLIC loguru::loguru) + #-------------------------------------------------------------------------- # executable for prototyping #-------------------------------------------------------------------------- diff --git a/diffCheckErrors.log b/diffCheckErrors.log new file mode 100644 index 00000000..092b5e99 --- /dev/null +++ b/diffCheckErrors.log @@ -0,0 +1,4 @@ +arguments: loguru +Current dir: F:\diffCheck +File verbosity level: -2 +date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log new file mode 100644 index 00000000..20fc75ab --- /dev/null +++ b/diffCheckEvery.log @@ -0,0 +1,6 @@ +arguments: loguru +Current dir: F:\diffCheck +File verbosity level: 9 +date time ( uptime ) [ thread name/id ] file:line v| +2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckEvery.log', mode: 'w', verbosity: 9 +2024-03-30 12:53:29.971 ( 0.001s) [main thread ] loguru.cpp:841 INFO| Logging to 'diffCheckErrors.log', mode: 'w', verbosity: -2 diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 2e421aba..8dacae2c 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,12 +1,12 @@ #pragma once - #include #include +#include // diffCheck includes #include "diffCheck/log.hh" -const diffCheck::Log LOG = diffCheck::Log(); +diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index e1d564c4..73e789f3 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -22,7 +22,11 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - dfMeshPtr->LoadFromPLY(pathMesh); + + DIFFCHECK_INFO("test"); + DIFFCHECK_WARN("test"); + DIFFCHECK_ERROR("test"); + DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); @@ -34,5 +38,6 @@ int main() vis->AddMesh(dfMeshPtr); vis->Run(); + return 0; } \ No newline at end of file From 8cf9894961541db1ccbb4286d34de721b099d3d4 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 14:04:00 +0100 Subject: [PATCH 112/141] FIX: minor const for logger --- src/diffCheck.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 8dacae2c..feff20a8 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -6,7 +6,7 @@ // diffCheck includes #include "diffCheck/log.hh" -diffCheck::Log LOG = diffCheck::Log(); +const diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" From b20c82cd201b64dcc24e70116e3c67c7329b8e90 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Tue, 2 Apr 2024 13:02:28 +0200 Subject: [PATCH 113/141] FIX: no logging to be pushed --- .gitignore | 166 +---------------------------------------------------- 1 file changed, 1 insertion(+), 165 deletions(-) diff --git a/.gitignore b/.gitignore index 81422a74..8b07029b 100644 --- a/.gitignore +++ b/.gitignore @@ -77,168 +77,4 @@ _deps temp/ # temporary logging file -*.log - -####################################### -## Python -####################################### -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -share/python-wheels/ -*.egg-info/ -.installed.cfg -*.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.nox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -*.py,cover -.hypothesis/ -.pytest_cache/ -cover/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -.pybuilder/ -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# IPython -profile_default/ -ipython_config.py - -# pyenv -# For a library or package, you might want to ignore these files since the code is -# intended to run in multiple environments; otherwise, check them in: -# .python-version - -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# poetry -# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. -# This is especially recommended for binary packages to ensure reproducibility, and is more -# commonly ignored for libraries. -# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control -#poetry.lock - -# pdm -# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. -#pdm.lock -# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it -# in version control. -# https://pdm.fming.dev/#use-with-ide -.pdm.toml - -# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm -__pypackages__/ - -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py - -# Environments -.env -.venv -env/ -venv/ -ENV/ -env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - -# pytype static type analyzer -.pytype/ - -# Cython debug symbols -cython_debug/ - -# PyCharm -# JetBrains specific template is maintained in a separate JetBrains.gitignore that can -# 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 +*.log \ No newline at end of file From 34e14a1bba64b9fc9ba2d65f8700f70ee5085ab9 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:15:12 +0200 Subject: [PATCH 114/141] ADD: refinedRegistration files to create PR --- src/diffCheck/registration/refinedRegistration.cc | 1 + src/diffCheck/registration/refinedRegistration.hh | 0 2 files changed, 1 insertion(+) create mode 100644 src/diffCheck/registration/refinedRegistration.cc create mode 100644 src/diffCheck/registration/refinedRegistration.hh diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc new file mode 100644 index 00000000..8c788329 --- /dev/null +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -0,0 +1 @@ +#include "refinedRegistration.hh" diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh new file mode 100644 index 00000000..e69de29b From b7ba041d641b9482869938952f9b60418b71c54d Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 21:26:27 +0200 Subject: [PATCH 115/141] WIP: Open3d ICP added to registration class --- diffCheckErrors.log | 2 +- diffCheckEvery.log | Bin 455 -> 737 bytes src/diffCheck.hh | 3 +-- .../registration/refinedRegistration.cc | 14 ++++++++++++++ .../registration/refinedRegistration.hh | 15 +++++++++++++++ src/diffCheckApp.cc | 18 ++++++++++++++---- 6 files changed, 45 insertions(+), 7 deletions(-) diff --git a/diffCheckErrors.log b/diffCheckErrors.log index 092b5e99..f104f3b2 100644 --- a/diffCheckErrors.log +++ b/diffCheckErrors.log @@ -1,4 +1,4 @@ arguments: loguru -Current dir: F:\diffCheck +Current dir: C:\Users\localuser\diffCheck File verbosity level: -2 date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log index 20fc75ab3c002c6a823ebfd050def47301387949..db78b7876f71cf76d09f829391a126f331532452 100644 GIT binary patch literal 737 zcmeHEyJ`b55KJx5KTLNv@YC9 zv$L9Q87btX;G->Eq-YCsWndgDw5oeg#HsUft9_}kGp_I3fwrGgygE;qh&M60yoaZW zyuz~-MrXoY*^R#tSfG5(#1bFK1CurgdZZ_3u>Mh;x4v#r-i3L@bbu6Z(OMTQazu0T z@={&wAL|LtJ;rEAq1jb<@^*A}S;-tZU6nqpq?prDDh(x@xC@J=6nFpiM*^3VzQvEe E0ivLg=l}o! literal 455 zcmchS&rZWI42SQ1ir=k6q9sj-pt(+~goNM$fJ0c)EFyoZG%1?2hbL3n1Q(9@V#}64 z`{O|+D_xuzj8`e7Vv|D14G0|=diE;xFl_d6_fhoPNX#<4`$@+GjGU!m=nBE3#1c{4 za|x`F#-(wE7sP##T)=TFZ?wSM_r}jO source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index e69de29b..4bec4ced 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -0,0 +1,15 @@ +#pragma once +# include "diffCheck.hh" + +# include + +namespace diffCheck::registration +{ + class RefinedRegistration + { + public: + static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + }; +} \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 73e789f3..3986bd13 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -23,10 +23,20 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - DIFFCHECK_INFO("test"); - DIFFCHECK_WARN("test"); - DIFFCHECK_ERROR("test"); - DIFFCHECK_FATAL("test"); + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; + + dfMeshPtr->LoadFromPLY(pathMesh); + dfPointCloudPtr->LoadFromPLY(pathCloud); + + std::shared_ptr dfGroundTruth; + dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + + // DIFFCHECK_INFO("test"); + // DIFFCHECK_WARN("test"); + // DIFFCHECK_ERROR("test"); + // DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From ebeedab731b86ff09f64e40dcb4ac01b6312a0df Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 22 Apr 2024 14:49:29 +0200 Subject: [PATCH 116/141] WIP: refined registrations implemented --- src/diffCheck/registration/refinedRegistration.cc | 11 +++++++++++ src/diffCheck/registration/refinedRegistration.hh | 3 +++ 2 files changed, 14 insertions(+) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0de763bb..0235a586 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -6,6 +6,17 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) { std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index 4bec4ced..edc5cb1e 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,5 +11,8 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); + static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file From 9228e158ce165f49dbdfac17f3b8c96e15e16d79 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 15:32:06 +0100 Subject: [PATCH 117/141] WIP: stashing before refactoring cmake project --- cmake/Dockerfile | 34 ++++++++++++++++ cmake/install_open3d.bat | 86 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 120 insertions(+) create mode 100644 cmake/Dockerfile create mode 100644 cmake/install_open3d.bat diff --git a/cmake/Dockerfile b/cmake/Dockerfile new file mode 100644 index 00000000..4bbe0042 --- /dev/null +++ b/cmake/Dockerfile @@ -0,0 +1,34 @@ +# Use the latest Windows Server Core image with .NET Framework 4.8. +FROM mcr.microsoft.com/windows/servercore:ltsc2019 + +# Restore the default Windows shell for correct batch processing. +SHELL ["cmd", "/S", "/C"] + +# Download and install CMake +ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi +RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait + +# Download and install Git +ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe +RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait + +# Download and install vcpkg +RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg +RUN C:\\vcpkg\\bootstrap-vcpkg.bat + +# Install Open3D and other dependencies with vcpkg +RUN C:\\vcpkg\\vcpkg install open3d +RUN C:\\vcpkg\\vcpkg integrate install + +# Set up the working directory +WORKDIR C:/project + +# Clone the project +RUN git clone https://github.com/yourusername/yourproject.git . + +# Run the build script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] +RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] + +# Set the entrypoint to your application's main executable +ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat new file mode 100644 index 00000000..981feb33 --- /dev/null +++ b/cmake/install_open3d.bat @@ -0,0 +1,86 @@ +@echo off +setlocal + +:: run the following in a pop up window to avoid the console window and ask to ru n ass admin +@echo off +:: BatchGotAdmin +:------------------------------------- +REM --> Check for permissions +>nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" + +REM --> If error flag set, we do not have admin. +if '%errorlevel%' NEQ '0' ( + echo Requesting administrative privileges... + goto UACPrompt +) else ( goto gotAdmin ) + +:UACPrompt + echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" + echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs" + + "%temp%\getadmin.vbs" + exit /B + +:gotAdmin + if exist "%temp%\getadmin.vbs" ( del "%temp%\getadmin.vbs" ) + pushd "%CD%" + CD /D "%~dp0" +:-------------------------------------- + + + +:: Define the download URL and the target directory +set "url=https://github.com/isl-org/Open3D/releases/download/v0.18.0/open3d-devel-windows-amd64-0.18.0.zip" +set "targetDir=C:\Program Files\Open3Dtest" + +:: Create the if the directory does not exist +if not exist "%targetDir%" mkdir "%targetDir% + +:: check if the directory was created +if not exist "%targetDir%" ( + echo Failed to create the target directory. + exit /b 1 +) + +:: Download the file +echo Downloading Open3D... +curl -L -o "%targetDir%\open3d.zip" "%url%" + +:: Check if the file was downloaded +if not exist "%targetDir%\open3d.zip" ( + echo Failed to download Open3D. + exit /b 1 +) + +:: Extract the file +echo Extracting Open3D... +powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" + +@REM :: Delete the downloaded zip file +@REM del "%targetDir%\open3d.zip" + +@REM :: Change to the target directory +@REM cd /d "%targetDir%" + +@REM :: Run the cmake commands +@REM echo Building Open3D... +@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build +@REM if errorlevel 1 ( +@REM echo Failed to run cmake configuration command. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target ALL_BUILD +@REM if errorlevel 1 ( +@REM echo Failed to build ALL_BUILD. +@REM exit /b 1 +@REM ) + +@REM cmake --build build --config Release --target INSTALL +@REM if errorlevel 1 ( +@REM echo Failed to install. +@REM exit /b 1 +@REM ) + +@REM echo Done. +@REM endlocal \ No newline at end of file From 36cd8b159d1fb517b8defd256d201adfab867c02 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:26:55 +0100 Subject: [PATCH 118/141] WIP: testing docker windows --- .gitmodules | 3 --- CMakeLists.txt | 30 ++++++++++++++++++++---------- cmake/Dockerfile => Dockerfile | 19 +++++-------------- src/diffCheckApp.cc | 14 -------------- 4 files changed, 25 insertions(+), 41 deletions(-) rename cmake/Dockerfile => Dockerfile (65%) diff --git a/.gitmodules b/.gitmodules index 64917aff..e74877f6 100644 --- a/.gitmodules +++ b/.gitmodules @@ -5,6 +5,3 @@ [submodule "deps/eigen"] path = deps/eigen url = https://gitlab.com/libeigen/eigen.git -[submodule "deps/loguru"] - path = deps/loguru - url = https://github.com/emilk/loguru.git diff --git a/CMakeLists.txt b/CMakeLists.txt index d3d19170..faa10ec7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -68,7 +68,17 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (pre-built binaries) --------------------------------------------- +# Open3D (pre-built binaries) ----------------------------------------------------- +# The options need to be the same as Open3D's default +# If Open3D is configured and built with custom options, you'll also need to +# specify the same custom options. +option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) +if(STATIC_WINDOWS_RUNTIME) + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +else() + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") +endif() + download_submodule_project(open3d) set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) @@ -93,17 +103,17 @@ if(WIN32) endif() endif() -# Boost (header only) ----------------------------------------------------- -download_submodule_project(boost) -target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) +# # Boost (from system) ----------------------------------------------------- +# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download +# find_package(Boost REQUIRED) + +# # print boost include dir +# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -# CGAL (header-only) ------------------------------------------------------ -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# loguru (header-only) ---------------------------------------------------- -download_submodule_project(loguru) -add_subdirectory(deps/loguru) -target_link_libraries(${SHARED_LIB_NAME} PUBLIC loguru::loguru) +# # CGAL (header-only) ------------------------------------------------------ +# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/cmake/Dockerfile b/Dockerfile similarity index 65% rename from cmake/Dockerfile rename to Dockerfile index 4bbe0042..34b2c6f8 100644 --- a/cmake/Dockerfile +++ b/Dockerfile @@ -12,23 +12,14 @@ RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait -# Download and install vcpkg -RUN git clone https://github.com/microsoft/vcpkg.git C:\\vcpkg -RUN C:\\vcpkg\\bootstrap-vcpkg.bat - -# Install Open3D and other dependencies with vcpkg -RUN C:\\vcpkg\\vcpkg install open3d -RUN C:\\vcpkg\\vcpkg integrate install - # Set up the working directory WORKDIR C:/project -# Clone the project -RUN git clone https://github.com/yourusername/yourproject.git . +# make the code available in the container +COPY . . + +# Run the cmake/config.bat script +RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] # Run the build script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -B build -S ."] RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] - -# Set the entrypoint to your application's main executable -ENTRYPOINT ["C:\\project\\build\\YourApp.exe"] \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 3986bd13..2bb6557b 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -22,21 +22,7 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - - std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; - // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; - dfMeshPtr->LoadFromPLY(pathMesh); - dfPointCloudPtr->LoadFromPLY(pathCloud); - - std::shared_ptr dfGroundTruth; - dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); - - // DIFFCHECK_INFO("test"); - // DIFFCHECK_WARN("test"); - // DIFFCHECK_ERROR("test"); - // DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From b6e00723f0e9cf944691ea332d44c662f183fe63 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:48:38 +0100 Subject: [PATCH 119/141] FIX: udpated correct istructions README --- CMakeLists.txt | 16 ++++---- Dockerfile | 25 ------------ README.md | 4 +- cmake/install_open3d.bat | 86 ---------------------------------------- src/diffCheck.hh | 1 + 5 files changed, 11 insertions(+), 121 deletions(-) delete mode 100644 Dockerfile delete mode 100644 cmake/install_open3d.bat diff --git a/CMakeLists.txt b/CMakeLists.txt index faa10ec7..4800e2d3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -103,17 +103,17 @@ if(WIN32) endif() endif() -# # Boost (from system) ----------------------------------------------------- -# # download and install from https://sourceforge.net/projects/boost/files/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe/download -# find_package(Boost REQUIRED) +# Boost (header only) ----------------------------------------------------- +download_submodule_project(boost) +target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# # print boost include dir -# message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") +# print boost include dir +message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) -# # CGAL (header-only) ------------------------------------------------------ -# target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# CGAL (header-only) ------------------------------------------------------ +target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) #-------------------------------------------------------------------------- # executable for prototyping diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index 34b2c6f8..00000000 --- a/Dockerfile +++ /dev/null @@ -1,25 +0,0 @@ -# Use the latest Windows Server Core image with .NET Framework 4.8. -FROM mcr.microsoft.com/windows/servercore:ltsc2019 - -# Restore the default Windows shell for correct batch processing. -SHELL ["cmd", "/S", "/C"] - -# Download and install CMake -ADD https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-win64-x64.msi C:\\temp\\cmake.msi -RUN powershell Start-Process -FilePath msiexec.exe -ArgumentList '/i', 'C:\\temp\\cmake.msi', '/quiet', '/norestart' -NoNewWindow -Wait - -# Download and install Git -ADD https://github.com/git-for-windows/git/releases/download/v2.33.0.windows.2/Git-2.33.0.2-64-bit.exe C:\\temp\\git.exe -RUN powershell Start-Process -FilePath C:\\temp\\git.exe -ArgumentList '/VERYSILENT' -NoNewWindow -Wait - -# Set up the working directory -WORKDIR C:/project - -# make the code available in the container -COPY . . - -# Run the cmake/config.bat script -RUN ["cmd", "/S", "/C", "cmake -DCMAKE_TOOLCHAIN_FILE=C:\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake -S . -B build -G "Visual Studio 16 2019" -A x64"] - -# Run the build script -RUN ["cmd", "/S", "/C", "cmake --build build --config Release"] diff --git a/README.md b/README.md index 62e95560..c2c7ee37 100644 --- a/README.md +++ b/README.md @@ -50,10 +50,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-open3d.git)) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) - `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-boost.git)) +- `Boost` for general utilities as pre-build binaries ## How to build c++ project To build and test the project, follow the following steps: diff --git a/cmake/install_open3d.bat b/cmake/install_open3d.bat deleted file mode 100644 index 981feb33..00000000 --- a/cmake/install_open3d.bat +++ /dev/null @@ -1,86 +0,0 @@ -@echo off -setlocal - -:: run the following in a pop up window to avoid the console window and ask to ru n ass admin -@echo off -:: BatchGotAdmin -:------------------------------------- -REM --> Check for permissions ->nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" - -REM --> If error flag set, we do not have admin. -if '%errorlevel%' NEQ '0' ( - echo Requesting administrative privileges... - goto UACPrompt -) else ( goto gotAdmin ) - -:UACPrompt - echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" - echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs" - - "%temp%\getadmin.vbs" - exit /B - -:gotAdmin - if exist "%temp%\getadmin.vbs" ( del "%temp%\getadmin.vbs" ) - pushd "%CD%" - CD /D "%~dp0" -:-------------------------------------- - - - -:: Define the download URL and the target directory -set "url=https://github.com/isl-org/Open3D/releases/download/v0.18.0/open3d-devel-windows-amd64-0.18.0.zip" -set "targetDir=C:\Program Files\Open3Dtest" - -:: Create the if the directory does not exist -if not exist "%targetDir%" mkdir "%targetDir% - -:: check if the directory was created -if not exist "%targetDir%" ( - echo Failed to create the target directory. - exit /b 1 -) - -:: Download the file -echo Downloading Open3D... -curl -L -o "%targetDir%\open3d.zip" "%url%" - -:: Check if the file was downloaded -if not exist "%targetDir%\open3d.zip" ( - echo Failed to download Open3D. - exit /b 1 -) - -:: Extract the file -echo Extracting Open3D... -powershell -Command "Expand-Archive -Path '%targetDir%\open3d.zip' -DestinationPath '%targetDir%'" - -@REM :: Delete the downloaded zip file -@REM del "%targetDir%\open3d.zip" - -@REM :: Change to the target directory -@REM cd /d "%targetDir%" - -@REM :: Run the cmake commands -@REM echo Building Open3D... -@REM cmake -DBUILD_WEBRTC=OFF -DBUILD_SHARED_LIBS=ON -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="%targetDir%" -S . -B build -@REM if errorlevel 1 ( -@REM echo Failed to run cmake configuration command. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target ALL_BUILD -@REM if errorlevel 1 ( -@REM echo Failed to build ALL_BUILD. -@REM exit /b 1 -@REM ) - -@REM cmake --build build --config Release --target INSTALL -@REM if errorlevel 1 ( -@REM echo Failed to install. -@REM exit /b 1 -@REM ) - -@REM echo Done. -@REM endlocal \ No newline at end of file diff --git a/src/diffCheck.hh b/src/diffCheck.hh index b3a4ec25..f31ee97a 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,5 +1,6 @@ #pragma once + #include #include #include From c6f5c2178617a8d551371627ab228678c8d76e91 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Fri, 29 Mar 2024 16:50:21 +0100 Subject: [PATCH 120/141] FIX: udpated correct istructions README x2 --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c2c7ee37..62e95560 100644 --- a/README.md +++ b/README.md @@ -50,10 +50,10 @@ gantt ## 3rd party libraries The project uses the following 3rd party libraries: -- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries) +- `Open3d 0.18.0` for 3D point cloud processing as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-open3d.git)) - `Eigen` for linear algebra - `CGAL` for general geometric processing and IO -- `Boost` for general utilities as pre-build binaries +- `Boost` for general utilities as pre-build binaries ([store here](https://github.com/diffCheckOrg/submodule-boost.git)) ## How to build c++ project To build and test the project, follow the following steps: From b1f400cc53dc487555490ad4c552b87f8e9f1d04 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 12:56:26 +0100 Subject: [PATCH 121/141] CAP: added logging --- .gitmodules | 3 +++ CMakeLists.txt | 22 ++++++---------------- diffCheckErrors.log | 2 +- diffCheckEvery.log | Bin 737 -> 0 bytes src/diffCheck.hh | 3 +-- src/diffCheckApp.cc | 6 +++++- 6 files changed, 16 insertions(+), 20 deletions(-) delete mode 100644 diffCheckEvery.log diff --git a/.gitmodules b/.gitmodules index e74877f6..64917aff 100644 --- a/.gitmodules +++ b/.gitmodules @@ -5,3 +5,6 @@ [submodule "deps/eigen"] path = deps/eigen url = https://gitlab.com/libeigen/eigen.git +[submodule "deps/loguru"] + path = deps/loguru + url = https://github.com/emilk/loguru.git diff --git a/CMakeLists.txt b/CMakeLists.txt index 4800e2d3..d3d19170 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -68,17 +68,7 @@ download_submodule_project(eigen) add_subdirectory(deps/eigen) target_link_libraries(${SHARED_LIB_NAME} PUBLIC Eigen3::Eigen) -# Open3D (pre-built binaries) ----------------------------------------------------- -# The options need to be the same as Open3D's default -# If Open3D is configured and built with custom options, you'll also need to -# specify the same custom options. -option(STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" ON) -if(STATIC_WINDOWS_RUNTIME) - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") -else() - set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") -endif() - +# Open3D (pre-built binaries) --------------------------------------------- download_submodule_project(open3d) set(Open3D_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps/open3d/win/0_18/CMake) find_package(Open3D 0.18.0 REQUIRED) @@ -107,14 +97,14 @@ endif() download_submodule_project(boost) target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85) -# print boost include dir -message(STATUS "Boost include dir: ${Boost_INCLUDE_DIRS}") - -target_include_directories(${SHARED_LIB_NAME} PUBLIC ${Boost_INCLUDE_DIRS}) - # CGAL (header-only) ------------------------------------------------------ target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include) +# loguru (header-only) ---------------------------------------------------- +download_submodule_project(loguru) +add_subdirectory(deps/loguru) +target_link_libraries(${SHARED_LIB_NAME} PUBLIC loguru::loguru) + #-------------------------------------------------------------------------- # executable for prototyping #-------------------------------------------------------------------------- diff --git a/diffCheckErrors.log b/diffCheckErrors.log index f104f3b2..092b5e99 100644 --- a/diffCheckErrors.log +++ b/diffCheckErrors.log @@ -1,4 +1,4 @@ arguments: loguru -Current dir: C:\Users\localuser\diffCheck +Current dir: F:\diffCheck File verbosity level: -2 date time ( uptime ) [ thread name/id ] file:line v| diff --git a/diffCheckEvery.log b/diffCheckEvery.log deleted file mode 100644 index db78b7876f71cf76d09f829391a126f331532452..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 737 zcmeHEyJ`b55KJx5KTLNv@YC9 zv$L9Q87btX;G->Eq-YCsWndgDw5oeg#HsUft9_}kGp_I3fwrGgygE;qh&M60yoaZW zyuz~-MrXoY*^R#tSfG5(#1bFK1CurgdZZ_3u>Mh;x4v#r-i3L@bbu6Z(OMTQazu0T z@={&wAL|LtJ;rEAq1jb<@^*A}S;-tZU6nqpq?prDDh(x@xC@J=6nFpiM*^3VzQvEe E0ivLg=l}o! diff --git a/src/diffCheck.hh b/src/diffCheck.hh index f31ee97a..399469ca 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -1,13 +1,12 @@ #pragma once - #include #include #include // diffCheck includes #include "diffCheck/log.hh" -const diffCheck::Log LOG = diffCheck::Log(); +diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 2bb6557b..73e789f3 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -22,7 +22,11 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - dfMeshPtr->LoadFromPLY(pathMesh); + + DIFFCHECK_INFO("test"); + DIFFCHECK_WARN("test"); + DIFFCHECK_ERROR("test"); + DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From b0d4068e9f0837c649ba14b3e2c1b463a4cddc67 Mon Sep 17 00:00:00 2001 From: Andrea Settimi Date: Sat, 30 Mar 2024 14:04:00 +0100 Subject: [PATCH 122/141] FIX: minor const for logger --- src/diffCheck.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffCheck.hh b/src/diffCheck.hh index 399469ca..b3a4ec25 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -6,7 +6,7 @@ // diffCheck includes #include "diffCheck/log.hh" -diffCheck::Log LOG = diffCheck::Log(); +const diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFPointCloud.hh" #include "diffCheck/geometry/DFMesh.hh" From f44069dc05c9d6c2d843de13504ffd4a07898704 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:15:12 +0200 Subject: [PATCH 123/141] ADD: refinedRegistration files to create PR --- .../registration/refinedRegistration.cc | 25 ------------------- 1 file changed, 25 deletions(-) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0235a586..8c788329 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -1,26 +1 @@ #include "refinedRegistration.hh" - - -namespace diffCheck::registration -{ - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; - } - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); - return result; - } -} \ No newline at end of file From 19bf804164e7ad613a29a03d7a0381459a649828 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 21:26:27 +0200 Subject: [PATCH 124/141] WIP: Open3d ICP added to registration class --- diffCheckErrors.log | 2 +- .../registration/refinedRegistration.cc | 14 ++++++++++++++ .../registration/refinedRegistration.hh | 3 --- src/diffCheckApp.cc | 18 ++++++++++++++---- 4 files changed, 29 insertions(+), 8 deletions(-) diff --git a/diffCheckErrors.log b/diffCheckErrors.log index 092b5e99..f104f3b2 100644 --- a/diffCheckErrors.log +++ b/diffCheckErrors.log @@ -1,4 +1,4 @@ arguments: loguru -Current dir: F:\diffCheck +Current dir: C:\Users\localuser\diffCheck File verbosity level: -2 date time ( uptime ) [ thread name/id ] file:line v| diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 8c788329..0de763bb 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -1 +1,15 @@ #include "refinedRegistration.hh" + + +namespace diffCheck::registration +{ + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index edc5cb1e..4bec4ced 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,8 +11,5 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); - static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 73e789f3..3986bd13 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -23,10 +23,20 @@ int main() // create a sphere from o3d auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); - DIFFCHECK_INFO("test"); - DIFFCHECK_WARN("test"); - DIFFCHECK_ERROR("test"); - DIFFCHECK_FATAL("test"); + std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; + + dfMeshPtr->LoadFromPLY(pathMesh); + dfPointCloudPtr->LoadFromPLY(pathCloud); + + std::shared_ptr dfGroundTruth; + dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + + // DIFFCHECK_INFO("test"); + // DIFFCHECK_WARN("test"); + // DIFFCHECK_ERROR("test"); + // DIFFCHECK_FATAL("test"); dfMeshPtr->Cvt2DFMesh(mesh); From 3e9d75283fa2a01c5fa61f0d3488667add71c2ec Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 22 Apr 2024 14:49:29 +0200 Subject: [PATCH 125/141] WIP: refined registrations implemented --- src/diffCheck/registration/refinedRegistration.cc | 11 +++++++++++ src/diffCheck/registration/refinedRegistration.hh | 3 +++ 2 files changed, 14 insertions(+) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0de763bb..0235a586 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -6,6 +6,17 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) { std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index 4bec4ced..edc5cb1e 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,5 +11,8 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); + static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file From 4598514487bf06c425c721a83521b3ae0b825e1a Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:15:12 +0200 Subject: [PATCH 126/141] ADD: refinedRegistration files to create PR --- .../registration/refinedRegistration.cc | 25 ------------------- 1 file changed, 25 deletions(-) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0235a586..8c788329 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -1,26 +1 @@ #include "refinedRegistration.hh" - - -namespace diffCheck::registration -{ - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; - } - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); - return result; - } -} \ No newline at end of file From 3cdf659d9f66127707faf1d5edfd8d58b01a9564 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 15 Apr 2024 21:26:27 +0200 Subject: [PATCH 127/141] WIP: Open3d ICP added to registration class --- src/diffCheck/registration/refinedRegistration.cc | 14 ++++++++++++++ src/diffCheck/registration/refinedRegistration.hh | 3 --- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 8c788329..0de763bb 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -1 +1,15 @@ #include "refinedRegistration.hh" + + +namespace diffCheck::registration +{ + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index edc5cb1e..4bec4ced 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,8 +11,5 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); - static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file From d8fe53b3f4a9b2479efa1a59be815aaccf239740 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Mon, 22 Apr 2024 14:49:29 +0200 Subject: [PATCH 128/141] WIP: refined registrations implemented --- src/diffCheck/registration/refinedRegistration.cc | 11 +++++++++++ src/diffCheck/registration/refinedRegistration.hh | 3 +++ 2 files changed, 14 insertions(+) diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc index 0de763bb..0235a586 100644 --- a/src/diffCheck/registration/refinedRegistration.cc +++ b/src/diffCheck/registration/refinedRegistration.cc @@ -6,6 +6,17 @@ namespace diffCheck::registration open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) { std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh index 4bec4ced..edc5cb1e 100644 --- a/src/diffCheck/registration/refinedRegistration.hh +++ b/src/diffCheck/registration/refinedRegistration.hh @@ -11,5 +11,8 @@ namespace diffCheck::registration static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, std::shared_ptr target, double maxCorrespondenceDistance = 0.01); + static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); }; } \ No newline at end of file From ab2b85b3c211644d02ede2865f5f724e736f3b5b Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 10:04:57 +0200 Subject: [PATCH 129/141] FIX: open3d and boost submodules erronously deleted: re-added using local git directory --- .gitmodules | 6 ++++++ deps/boost | 1 + deps/open3d | 1 + 3 files changed, 8 insertions(+) create mode 160000 deps/boost create mode 160000 deps/open3d diff --git a/.gitmodules b/.gitmodules index 64917aff..4614a235 100644 --- a/.gitmodules +++ b/.gitmodules @@ -8,3 +8,9 @@ [submodule "deps/loguru"] path = deps/loguru url = https://github.com/emilk/loguru.git +[submodule "deps/boost"] + path = deps/boost + url = https://github.com/diffCheckOrg/submodule-boost.git +[submodule "deps/open3d"] + path = deps/open3d + url = https://github.com/diffCheckOrg/submodule-open3d.git diff --git a/deps/boost b/deps/boost new file mode 160000 index 00000000..ee2a0a55 --- /dev/null +++ b/deps/boost @@ -0,0 +1 @@ +Subproject commit ee2a0a555b6fe33458ae19bfa1e193d8e67bb6e9 diff --git a/deps/open3d b/deps/open3d new file mode 160000 index 00000000..7f83ddfc --- /dev/null +++ b/deps/open3d @@ -0,0 +1 @@ +Subproject commit 7f83ddfcbbb512824f358c365a3c62f6cd246f87 From fbd16db07c70a09c387fc993d067e01fa1e1864c Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 10:21:37 +0200 Subject: [PATCH 130/141] WIP: change file name to DFRefinedRegistration and add documentation --- .../registration/DFRefinedRegistration.cc | 32 ++++++++++++++++ .../registration/DFRefinedRegistration.hh | 37 +++++++++++++++++++ .../registration/refinedRegistration.cc | 26 ------------- .../registration/refinedRegistration.hh | 18 --------- 4 files changed, 69 insertions(+), 44 deletions(-) create mode 100644 src/diffCheck/registration/DFRefinedRegistration.cc create mode 100644 src/diffCheck/registration/DFRefinedRegistration.hh delete mode 100644 src/diffCheck/registration/refinedRegistration.cc delete mode 100644 src/diffCheck/registration/refinedRegistration.hh diff --git a/src/diffCheck/registration/DFRefinedRegistration.cc b/src/diffCheck/registration/DFRefinedRegistration.cc new file mode 100644 index 00000000..a619e571 --- /dev/null +++ b/src/diffCheck/registration/DFRefinedRegistration.cc @@ -0,0 +1,32 @@ +#include "refinedRegistration.hh" + + +namespace diffCheck::registration +{ + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registration/DFRefinedRegistration.hh b/src/diffCheck/registration/DFRefinedRegistration.hh new file mode 100644 index 00000000..c59561cc --- /dev/null +++ b/src/diffCheck/registration/DFRefinedRegistration.hh @@ -0,0 +1,37 @@ +#pragma once +# include "diffCheck.hh" + +# include + +namespace diffCheck::registration +{ + class RefinedRegistration + { + public: ///< open3d registration methods + /** + * @brief Perform ICP registration using Open3D + * + * @param source DFPointCloud source point cloud + * @param target DFPointCloud Target point cloud + * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @return diffCheck::transformation::DFTransformation + */ + static diffCheck::transformation::DFTransformation O3DICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + + /** + * @brief Perform Generalized ICP registration using Open3D + * + * @param source DFPointCloud source point cloud + * @param target DFPointCloud Target point cloud + * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @return diffCheck::transformation::DFTransformation + */ + static diffCheck::transformation::DFTransformation O3DGeneralizedICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + }; +} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.cc b/src/diffCheck/registration/refinedRegistration.cc deleted file mode 100644 index 0235a586..00000000 --- a/src/diffCheck/registration/refinedRegistration.cc +++ /dev/null @@ -1,26 +0,0 @@ -#include "refinedRegistration.hh" - - -namespace diffCheck::registration -{ - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; - } - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP(*O3Dsource, *O3Dtarget, maxCorrespondenceDistance); - return result; - } -} \ No newline at end of file diff --git a/src/diffCheck/registration/refinedRegistration.hh b/src/diffCheck/registration/refinedRegistration.hh deleted file mode 100644 index edc5cb1e..00000000 --- a/src/diffCheck/registration/refinedRegistration.hh +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once -# include "diffCheck.hh" - -# include - -namespace diffCheck::registration -{ - class RefinedRegistration - { - public: - static open3d::pipelines::registration::RegistrationResult O3DICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); - static open3d::pipelines::registration::RegistrationResult O3DGeneralizedICP(std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); - }; -} \ No newline at end of file From 2bb29ed53e64a398089b808d9a8b155d496dad8d Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 10:33:39 +0200 Subject: [PATCH 131/141] WIP: rebase on main --- deps/eigen | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deps/eigen b/deps/eigen index 34967b0b..9700fc84 160000 --- a/deps/eigen +++ b/deps/eigen @@ -1 +1 @@ -Subproject commit 34967b0b5ba974cddd06c3a957e6b42ba620ed22 +Subproject commit 9700fc847a39e98dfb7bd85331b5206641050e04 From 455881e028fb87774bef18092627d125a5ea0569 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 10:40:02 +0200 Subject: [PATCH 132/141] FIX: folder naming --- .../registrations/DFRefinedRegistration.cc | 32 ++++++++++++++++ .../registrations/DFRefinedRegistration.hh | 37 +++++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 src/diffCheck/registrations/DFRefinedRegistration.cc create mode 100644 src/diffCheck/registrations/DFRefinedRegistration.hh diff --git a/src/diffCheck/registrations/DFRefinedRegistration.cc b/src/diffCheck/registrations/DFRefinedRegistration.cc new file mode 100644 index 00000000..a619e571 --- /dev/null +++ b/src/diffCheck/registrations/DFRefinedRegistration.cc @@ -0,0 +1,32 @@ +#include "refinedRegistration.hh" + + +namespace diffCheck::registration +{ + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } + open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance) + { + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); + std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); + open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + maxCorrespondenceDistance); + return result; + } +} \ No newline at end of file diff --git a/src/diffCheck/registrations/DFRefinedRegistration.hh b/src/diffCheck/registrations/DFRefinedRegistration.hh new file mode 100644 index 00000000..c59561cc --- /dev/null +++ b/src/diffCheck/registrations/DFRefinedRegistration.hh @@ -0,0 +1,37 @@ +#pragma once +# include "diffCheck.hh" + +# include + +namespace diffCheck::registration +{ + class RefinedRegistration + { + public: ///< open3d registration methods + /** + * @brief Perform ICP registration using Open3D + * + * @param source DFPointCloud source point cloud + * @param target DFPointCloud Target point cloud + * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @return diffCheck::transformation::DFTransformation + */ + static diffCheck::transformation::DFTransformation O3DICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + + /** + * @brief Perform Generalized ICP registration using Open3D + * + * @param source DFPointCloud source point cloud + * @param target DFPointCloud Target point cloud + * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @return diffCheck::transformation::DFTransformation + */ + static diffCheck::transformation::DFTransformation O3DGeneralizedICP( + std::shared_ptr source, + std::shared_ptr target, + double maxCorrespondenceDistance = 0.01); + }; +} \ No newline at end of file From f852b9702de89b32082d6d2d9e8bdc6d4d8747ee Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 10:41:07 +0200 Subject: [PATCH 133/141] FIX: folder naming --- .../registration/DFRefinedRegistration.cc | 32 ---------------- .../registration/DFRefinedRegistration.hh | 37 ------------------- 2 files changed, 69 deletions(-) delete mode 100644 src/diffCheck/registration/DFRefinedRegistration.cc delete mode 100644 src/diffCheck/registration/DFRefinedRegistration.hh diff --git a/src/diffCheck/registration/DFRefinedRegistration.cc b/src/diffCheck/registration/DFRefinedRegistration.cc deleted file mode 100644 index a619e571..00000000 --- a/src/diffCheck/registration/DFRefinedRegistration.cc +++ /dev/null @@ -1,32 +0,0 @@ -#include "refinedRegistration.hh" - - -namespace diffCheck::registration -{ - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP( - std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( - *O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; - } - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP( - std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance) - { - std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); - std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( - *O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; - } -} \ No newline at end of file diff --git a/src/diffCheck/registration/DFRefinedRegistration.hh b/src/diffCheck/registration/DFRefinedRegistration.hh deleted file mode 100644 index c59561cc..00000000 --- a/src/diffCheck/registration/DFRefinedRegistration.hh +++ /dev/null @@ -1,37 +0,0 @@ -#pragma once -# include "diffCheck.hh" - -# include - -namespace diffCheck::registration -{ - class RefinedRegistration - { - public: ///< open3d registration methods - /** - * @brief Perform ICP registration using Open3D - * - * @param source DFPointCloud source point cloud - * @param target DFPointCloud Target point cloud - * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal - * @return diffCheck::transformation::DFTransformation - */ - static diffCheck::transformation::DFTransformation O3DICP( - std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); - - /** - * @brief Perform Generalized ICP registration using Open3D - * - * @param source DFPointCloud source point cloud - * @param target DFPointCloud Target point cloud - * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal - * @return diffCheck::transformation::DFTransformation - */ - static diffCheck::transformation::DFTransformation O3DGeneralizedICP( - std::shared_ptr source, - std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); - }; -} \ No newline at end of file From a3b23a298f432e9da895f9c93cc6b789ff522c75 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 17:45:14 +0200 Subject: [PATCH 134/141] ADD: ICP refined registrations with exposed parameters --- .../registrations/DFRefinedRegistration.cc | 101 +++++++++++++++--- .../registrations/DFRefinedRegistration.hh | 20 +++- 2 files changed, 103 insertions(+), 18 deletions(-) diff --git a/src/diffCheck/registrations/DFRefinedRegistration.cc b/src/diffCheck/registrations/DFRefinedRegistration.cc index a619e571..07773d31 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.cc +++ b/src/diffCheck/registrations/DFRefinedRegistration.cc @@ -1,32 +1,101 @@ -#include "refinedRegistration.hh" +#include "DFRefinedRegistration.hh" namespace diffCheck::registration { - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DICP( + diffCheck::transformation::DFTransformation RefinedRegistration::O3DICP( std::shared_ptr source, std::shared_ptr target, - double maxCorrespondenceDistance) + double maxCorrespondenceDistance, + bool scalingForPointToPointTransformationEstimation, + double relativeFitness, + double relativeRMSE, + int maxIteration, + bool usePointToPlane) { + std::vector minMax = source->ComputeBoundingBox(); + double scale = (minMax[1] - minMax[0]).norm(); + double absoluteMaxCorrespondenceDistance = maxCorrespondenceDistance * scale; + + std::cout<<"Absolute Max Correspondence Distance: "< O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( - *O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; + Eigen::Matrix4d initialTransformation = Eigen::Matrix4d::Identity(); + open3d::pipelines::registration::ICPConvergenceCriteria criteria + = open3d::pipelines::registration::ICPConvergenceCriteria( + relativeFitness, + relativeRMSE, + maxIteration); + + open3d::pipelines::registration::RegistrationResult result; + + if(usePointToPlane) + { + open3d::pipelines::registration::TransformationEstimationPointToPlane transformation_estimation + = open3d::pipelines::registration::TransformationEstimationPointToPlane(); + result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + absoluteMaxCorrespondenceDistance, + initialTransformation, + transformation_estimation, + criteria); + } + else + { + open3d::pipelines::registration::TransformationEstimationPointToPoint transformation_estimation + = open3d::pipelines::registration::TransformationEstimationPointToPoint(scalingForPointToPointTransformationEstimation); + result = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + absoluteMaxCorrespondenceDistance, + initialTransformation, + transformation_estimation, + criteria); + } + diffCheck::transformation::DFTransformation transformation + = diffCheck::transformation::DFTransformation(result.transformation_); + return transformation; } - open3d::pipelines::registration::RegistrationResult RefinedRegistration::O3DGeneralizedICP( - std::shared_ptr source, + diffCheck::transformation::DFTransformation RefinedRegistration::O3DGeneralizedICP( + std::shared_ptr source, std::shared_ptr target, - double maxCorrespondenceDistance) + double maxCorrespondenceDistance, + int maxIteration, + double relativeFitness, + double relativeRMSE) { + std::vector minMax = source->ComputeBoundingBox(); + double scale = (minMax[1] - minMax[0]).norm(); + double absoluteMaxCorrespondenceDistance = maxCorrespondenceDistance * scale; + std::shared_ptr O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); - open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::RegistrationICP( - *O3Dsource, - *O3Dtarget, - maxCorrespondenceDistance); - return result; + + O3Dsource->EstimateCovariances(); + O3Dtarget->EstimateCovariances(); + + Eigen::Matrix4d initialTransformation = Eigen::Matrix4d::Identity(); + open3d::pipelines::registration::ICPConvergenceCriteria criteria + = open3d::pipelines::registration::ICPConvergenceCriteria( + relativeFitness, + relativeRMSE, + maxIteration); + + open3d::pipelines::registration::TransformationEstimationForGeneralizedICP transformation_estimation + = open3d::pipelines::registration::TransformationEstimationForGeneralizedICP(); + + open3d::pipelines::registration::RegistrationResult result + = open3d::pipelines::registration::RegistrationICP( + *O3Dsource, + *O3Dtarget, + absoluteMaxCorrespondenceDistance, + initialTransformation, + transformation_estimation, + criteria); + + diffCheck::transformation::DFTransformation transformation + = diffCheck::transformation::DFTransformation(result.transformation_); + return transformation; } } \ No newline at end of file diff --git a/src/diffCheck/registrations/DFRefinedRegistration.hh b/src/diffCheck/registrations/DFRefinedRegistration.hh index c59561cc..d79e21a9 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.hh +++ b/src/diffCheck/registrations/DFRefinedRegistration.hh @@ -14,12 +14,22 @@ namespace diffCheck::registration * @param source DFPointCloud source point cloud * @param target DFPointCloud Target point cloud * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @param scalingForPointToPointTransformationEstimation Enable scaling for point-to-point transformation estimation. by default it is false, to only allow rigid transformations + * @param maxIteration Maximum number of ICP iterations to use in the p2p transformation estimation + * @param relativeFitness Threshold for relative fitness to use in the p2p transformation estimation + * @param relativeRMSE Threshold for relative RMSE to use in the p2p transformation estimation + * @param usePointToPlane Use point-to-plane ICP instead of point-to-point. This replaces the p2p with the point-to-plane transformation estimation * @return diffCheck::transformation::DFTransformation */ static diffCheck::transformation::DFTransformation O3DICP( std::shared_ptr source, std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); + double maxCorrespondenceDistance = 0.01, + bool scalingForPointToPointTransformationEstimation = false, + double relativeFitness = 1e-6, + double relativeRMSE = 1e-6, + int maxIteration = 30, + bool usePointToPlane = false); /** * @brief Perform Generalized ICP registration using Open3D @@ -27,11 +37,17 @@ namespace diffCheck::registration * @param source DFPointCloud source point cloud * @param target DFPointCloud Target point cloud * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal + * @param maxIteration Maximum number of ICP iterations to use in the p2p transformation estimation + * @param relativeFitness Threshold for relative fitness to use in the p2p transformation estimation + * @param relativeRMSE Threshold for relative RMSE to use in the p2p transformation estimation * @return diffCheck::transformation::DFTransformation */ static diffCheck::transformation::DFTransformation O3DGeneralizedICP( std::shared_ptr source, std::shared_ptr target, - double maxCorrespondenceDistance = 0.01); + double maxCorrespondenceDistance = 0.01, + int maxIteration = 30, + double relativeFitness = 1e-6, + double relativeRMSE = 1e-6); }; } \ No newline at end of file From bd6de0a33a7493175fe386d471e760301600404d Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 17:46:15 +0200 Subject: [PATCH 135/141] ADD: ICP refined registrations with exposed parameters --- src/diffCheck.hh | 2 +- src/diffCheckApp.cc | 28 +++++++++++++++++----------- 2 files changed, 18 insertions(+), 12 deletions(-) diff --git a/src/diffCheck.hh b/src/diffCheck.hh index b3a4ec25..5a299d98 100644 --- a/src/diffCheck.hh +++ b/src/diffCheck.hh @@ -12,4 +12,4 @@ const diffCheck::Log LOG = diffCheck::Log(); #include "diffCheck/geometry/DFMesh.hh" #include "diffCheck/IOManager.hh" #include "diffCheck/visualizer.hh" -#include "diffCheck/registration/refinedRegistration.hh" \ No newline at end of file +#include "diffCheck/registrations/DFRefinedRegistration.hh" \ No newline at end of file diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 3986bd13..9b62e4b2 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -15,13 +15,13 @@ int main() std::shared_ptr dfPointCloudPtrGroundTruth = std::make_shared(); std::shared_ptr dfPointCloudPtrGroundTruthFromMesh = std::make_shared(); std::shared_ptr dfMeshPtr = std::make_shared(); + std::shared_ptr dfGroundTruth = std::make_shared(); // std::string pathCloud = R"(C:\Users\andre\Downloads\scan_data_normals.ply\scan_data_normals.ply)"; // std::string pathMesh = R"(F:\diffCheck\assets\dataset\mesh_fromRh_unfixedLength.ply)"; // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; // create a sphere from o3d - auto mesh = open3d::geometry::TriangleMesh::CreateSphere(1.0, 4); std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; @@ -30,24 +30,30 @@ int main() dfMeshPtr->LoadFromPLY(pathMesh); dfPointCloudPtr->LoadFromPLY(pathCloud); - std::shared_ptr dfGroundTruth; dfGroundTruth->Cvt2DFPointCloud(dfMeshPtr->Cvt2O3DTriangleMesh()->SamplePointsUniformly(10000)); + Eigen::Matrix4d transformation = Eigen::Matrix4d::Identity(); + transformation(0, 3) = 0.0; + transformation(1, 3) = -0.02; + transformation(2, 3) = 0.02; + Eigen::Matrix3d rotation; + rotation = Eigen::AngleAxisd(0, Eigen::Vector3d::UnitY()); + transformation.block<3, 3>(0, 0) = rotation * transformation.block<3, 3>(0, 0); - // DIFFCHECK_INFO("test"); - // DIFFCHECK_WARN("test"); - // DIFFCHECK_ERROR("test"); - // DIFFCHECK_FATAL("test"); + dfPointCloudPtr->ApplyTransformation(transformation); + diffCheck::transformation::DFTransformation localRegistration = diffCheck::registration::RefinedRegistration::O3DICP(dfPointCloudPtr, dfGroundTruth, 0.05); - dfMeshPtr->Cvt2DFMesh(mesh); - - // dfPointCloudPtr->LoadFromPLY(pathCloud); + diffCheck::transformation::DFTransformation otherlocalRegistration = diffCheck::registration::RefinedRegistration::O3DGeneralizedICP(dfPointCloudPtr, dfGroundTruth, 0.05); + dfPointCloudPtr->ApplyTransformation(localRegistration); + std::cout< vis = std::make_shared(); // vis->AddPointCloud(dfPointCloudPtr); vis->AddMesh(dfMeshPtr); + vis->AddPointCloud(dfGroundTruth); + vis->AddPointCloud(dfPointCloudPtr); vis->Run(); - - return 0; } \ No newline at end of file From 283b57f32a0933cf620f148aec9bc7426fb57942 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Thu, 2 May 2024 18:38:27 +0200 Subject: [PATCH 136/141] Fix: GeneralizedICP --- .../registrations/DFRefinedRegistration.cc | 3 +-- src/diffCheckApp.cc | 26 ++++++++++++------- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/src/diffCheck/registrations/DFRefinedRegistration.cc b/src/diffCheck/registrations/DFRefinedRegistration.cc index 07773d31..5e44b4cb 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.cc +++ b/src/diffCheck/registrations/DFRefinedRegistration.cc @@ -17,7 +17,6 @@ namespace diffCheck::registration double scale = (minMax[1] - minMax[0]).norm(); double absoluteMaxCorrespondenceDistance = maxCorrespondenceDistance * scale; - std::cout<<"Absolute Max Correspondence Distance: "< O3Dsource = source->Cvt2O3DPointCloud(); std::shared_ptr O3Dtarget = target->Cvt2O3DPointCloud(); Eigen::Matrix4d initialTransformation = Eigen::Matrix4d::Identity(); @@ -86,7 +85,7 @@ namespace diffCheck::registration = open3d::pipelines::registration::TransformationEstimationForGeneralizedICP(); open3d::pipelines::registration::RegistrationResult result - = open3d::pipelines::registration::RegistrationICP( + = open3d::pipelines::registration::RegistrationGeneralizedICP( *O3Dsource, *O3Dtarget, absoluteMaxCorrespondenceDistance, diff --git a/src/diffCheckApp.cc b/src/diffCheckApp.cc index 9b62e4b2..0566c961 100644 --- a/src/diffCheckApp.cc +++ b/src/diffCheckApp.cc @@ -23,8 +23,8 @@ int main() // create a sphere from o3d - std::string pathCloud = R"(C:\Users\localuser\Downloads\00_pt.ply)"; - std::string pathMesh = R"(C:\Users\localuser\Downloads\00_mesh.ply)"; + std::string pathCloud = R"(C:\Users\localuser\Downloads\04_pt.ply)"; + std::string pathMesh = R"(C:\Users\localuser\Downloads\04_mesh.ply)"; // std::string pathMesh = R"(F:\diffCheck\temp\03_mesh.ply)"; dfMeshPtr->LoadFromPLY(pathMesh); @@ -36,19 +36,27 @@ int main() transformation(1, 3) = -0.02; transformation(2, 3) = 0.02; Eigen::Matrix3d rotation; - rotation = Eigen::AngleAxisd(0, Eigen::Vector3d::UnitY()); + rotation = Eigen::AngleAxisd(0.3, Eigen::Vector3d::UnitY()); transformation.block<3, 3>(0, 0) = rotation * transformation.block<3, 3>(0, 0); dfPointCloudPtr->ApplyTransformation(transformation); - diffCheck::transformation::DFTransformation localRegistration = diffCheck::registration::RefinedRegistration::O3DICP(dfPointCloudPtr, dfGroundTruth, 0.05); + diffCheck::transformation::DFTransformation simpleICPTransformation + = diffCheck::registration::RefinedRegistration::O3DICP( + dfPointCloudPtr, + dfGroundTruth, + 0.05); - diffCheck::transformation::DFTransformation otherlocalRegistration = diffCheck::registration::RefinedRegistration::O3DGeneralizedICP(dfPointCloudPtr, dfGroundTruth, 0.05); - dfPointCloudPtr->ApplyTransformation(localRegistration); + diffCheck::transformation::DFTransformation generalizedICPTransformation + = diffCheck::registration::RefinedRegistration::O3DGeneralizedICP( + dfPointCloudPtr, + dfGroundTruth, + 0.05); + dfPointCloudPtr->ApplyTransformation(simpleICPTransformation); + + std::cout< vis = std::make_shared(); // vis->AddPointCloud(dfPointCloudPtr); vis->AddMesh(dfMeshPtr); From e7de865e978a43aafdfb46a34b1791c6b0b7c9c5 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 3 May 2024 10:16:20 +0200 Subject: [PATCH 137/141] WIP-FIX: normal computation for point to plane ICP added, and improvement of documentation of ICP --- .../registrations/DFRefinedRegistration.cc | 2 ++ .../registrations/DFRefinedRegistration.hh | 16 +++++++++++++--- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/src/diffCheck/registrations/DFRefinedRegistration.cc b/src/diffCheck/registrations/DFRefinedRegistration.cc index 5e44b4cb..3e0c7363 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.cc +++ b/src/diffCheck/registrations/DFRefinedRegistration.cc @@ -30,6 +30,8 @@ namespace diffCheck::registration if(usePointToPlane) { + O3Dsource->EstimateNormals(); + O3Dtarget->EstimateNormals(); open3d::pipelines::registration::TransformationEstimationPointToPlane transformation_estimation = open3d::pipelines::registration::TransformationEstimationPointToPlane(); result = open3d::pipelines::registration::RegistrationICP( diff --git a/src/diffCheck/registrations/DFRefinedRegistration.hh b/src/diffCheck/registrations/DFRefinedRegistration.hh index d79e21a9..9a356ee6 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.hh +++ b/src/diffCheck/registrations/DFRefinedRegistration.hh @@ -11,6 +11,10 @@ namespace diffCheck::registration /** * @brief Perform ICP registration using Open3D * + * The ICP registration looks for points in the target point cloud that are closest to the source + * point cloud and computes the transformation that minimizes the distance between the two point clouds. + * The way the distance is either calculated with point to point or point to plane methods. + * * @param source DFPointCloud source point cloud * @param target DFPointCloud Target point cloud * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal @@ -18,13 +22,13 @@ namespace diffCheck::registration * @param maxIteration Maximum number of ICP iterations to use in the p2p transformation estimation * @param relativeFitness Threshold for relative fitness to use in the p2p transformation estimation * @param relativeRMSE Threshold for relative RMSE to use in the p2p transformation estimation - * @param usePointToPlane Use point-to-plane ICP instead of point-to-point. This replaces the p2p with the point-to-plane transformation estimation + * @param usePointToPlane Use point-to-plane ICP instead of point-to-point. This replaces the p2p with the point-to-plane transformation estimation. * @return diffCheck::transformation::DFTransformation */ static diffCheck::transformation::DFTransformation O3DICP( std::shared_ptr source, std::shared_ptr target, - double maxCorrespondenceDistance = 0.01, + double maxCorrespondenceDistance = 0.05, bool scalingForPointToPointTransformationEstimation = false, double relativeFitness = 1e-6, double relativeRMSE = 1e-6, @@ -34,6 +38,10 @@ namespace diffCheck::registration /** * @brief Perform Generalized ICP registration using Open3D * + * The Generalized ICP registration additionally identifies planes in the source and target + * point clouds and uses them to improve the registration. According to the original 2009 paper, + * it can be seen as a "plane-to-plane" ICP. The paper is called "Generalized-ICP" and is referenced below. + * * @param source DFPointCloud source point cloud * @param target DFPointCloud Target point cloud * @param maxCorrespondenceDistance Maximum relative correspondence distance. 0.01 means 1% of the bounding box diagonal @@ -41,11 +49,13 @@ namespace diffCheck::registration * @param relativeFitness Threshold for relative fitness to use in the p2p transformation estimation * @param relativeRMSE Threshold for relative RMSE to use in the p2p transformation estimation * @return diffCheck::transformation::DFTransformation + * + * @see https://www.robots.ox.ac.uk/~avsegal/resources/papers/Generalized_ICP.pdf for more information */ static diffCheck::transformation::DFTransformation O3DGeneralizedICP( std::shared_ptr source, std::shared_ptr target, - double maxCorrespondenceDistance = 0.01, + double maxCorrespondenceDistance = 0.05, int maxIteration = 30, double relativeFitness = 1e-6, double relativeRMSE = 1e-6); From c5837679b19517e9c7625cfb3a765570ecf69805 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 3 May 2024 10:27:38 +0200 Subject: [PATCH 138/141] CAP: Fully functionning and documented O3D ICP registration methods --- src/diffCheck/registrations/DFRefinedRegistration.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/diffCheck/registrations/DFRefinedRegistration.cc b/src/diffCheck/registrations/DFRefinedRegistration.cc index 3e0c7363..46ea511d 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.cc +++ b/src/diffCheck/registrations/DFRefinedRegistration.cc @@ -54,6 +54,7 @@ namespace diffCheck::registration transformation_estimation, criteria); } + diffCheck::transformation::DFTransformation transformation = diffCheck::transformation::DFTransformation(result.transformation_); return transformation; From 746d49b11582326c2c259fb40a52cad89eab71d0 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 3 May 2024 10:29:46 +0200 Subject: [PATCH 139/141] FIX: doi instead of URL for external reference --- src/diffCheck/registrations/DFRefinedRegistration.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffCheck/registrations/DFRefinedRegistration.hh b/src/diffCheck/registrations/DFRefinedRegistration.hh index 9a356ee6..0bbbbb3d 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.hh +++ b/src/diffCheck/registrations/DFRefinedRegistration.hh @@ -50,7 +50,7 @@ namespace diffCheck::registration * @param relativeRMSE Threshold for relative RMSE to use in the p2p transformation estimation * @return diffCheck::transformation::DFTransformation * - * @see https://www.robots.ox.ac.uk/~avsegal/resources/papers/Generalized_ICP.pdf for more information + * @see http://dx.doi.org/10.15607/RSS.2009.V.021 for more information */ static diffCheck::transformation::DFTransformation O3DGeneralizedICP( std::shared_ptr source, From f366cd643389c930b9146bd7b455c2a8b8a5c607 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 3 May 2024 10:34:09 +0200 Subject: [PATCH 140/141] FIX: solve .gitmodule merge conflict --- .gitmodules | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/.gitmodules b/.gitmodules index 4614a235..b5ab7242 100644 --- a/.gitmodules +++ b/.gitmodules @@ -5,12 +5,15 @@ [submodule "deps/eigen"] path = deps/eigen url = https://gitlab.com/libeigen/eigen.git -[submodule "deps/loguru"] - path = deps/loguru - url = https://github.com/emilk/loguru.git -[submodule "deps/boost"] - path = deps/boost - url = https://github.com/diffCheckOrg/submodule-boost.git [submodule "deps/open3d"] path = deps/open3d url = https://github.com/diffCheckOrg/submodule-open3d.git +[submodule "deps/boost"] + path = deps/boost + url = https://github.com/diffCheckOrg/submodule-boost.git +[submodule "deps/loguru"] + path = deps/loguru + url = https://github.com/emilk/loguru.git +[submodule "deps/pybind11"] + path = deps/pybind11 + url = https://github.com/pybind/pybind11.git \ No newline at end of file From c4979702c57bc0e7690653446100dfbdd18cf2a1 Mon Sep 17 00:00:00 2001 From: DamienGilliard <127743632+DamienGilliard@users.noreply.github.com> Date: Fri, 3 May 2024 10:58:31 +0200 Subject: [PATCH 141/141] FIX: sentence in documentation not clear --- src/diffCheck/registrations/DFRefinedRegistration.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffCheck/registrations/DFRefinedRegistration.hh b/src/diffCheck/registrations/DFRefinedRegistration.hh index 0bbbbb3d..1d0bb322 100644 --- a/src/diffCheck/registrations/DFRefinedRegistration.hh +++ b/src/diffCheck/registrations/DFRefinedRegistration.hh @@ -13,7 +13,7 @@ namespace diffCheck::registration * * The ICP registration looks for points in the target point cloud that are closest to the source * point cloud and computes the transformation that minimizes the distance between the two point clouds. - * The way the distance is either calculated with point to point or point to plane methods. + * The way the distance is calculated is either with point to point or point to plane methods. * * @param source DFPointCloud source point cloud * @param target DFPointCloud Target point cloud