refactor: update SmartPointer default constructor to initialize as null and add comprehensive documentation

docs/object_context.md

@@ -2,7 +2,15 @@
 
 In uLib the context is meant to hold a set of objects and their hierarchy. In addition ObjectFactory is used to create objects from a predefined registry. 
 
-Object context can be thouught as a collection of uLib::Object instances. And there exists nested collection of objects if a context is added to another context. A nested context is a Group of elements that appears like a single object in the parent context and a hierarchy of objects inside the tree structure. 
+Object context can be thought as a collection of uLib::Object instances. And there exists nested collection of objects if a context is added to another context. A nested context is a Group of elements that appears like a single object in the parent context and a hierarchy of objects inside the tree structure. 
+
+## SmartPointer access
+
+SmartPointer is a class that is used to hold a reference to another object. It is a template class that can be used to hold a reference to any object as a shared_ptr. 
+
+The ObjectContext is responsible to keep track of all the objects that are added to it and to provide a way to access them, but also it holds the SmartPointer instances that point to the objects that are added to it. In this way Objects added to a Context are disposed only when all the references to it are removed.
+For this reason the access to a object context for a Object via Get/Set must be done using the SmartPointer instances.
+
 
 ## SmartPointer access
 

docs/smart_pointer.md

@@ -0,0 +1,120 @@
+# SmartPointer Documentation
+
+`uLib::SmartPointer<T>` is a shared ownership smart pointer implementation designed for the `uLib` ecosystem. While it shares many similarities with `std::shared_ptr`, it includes specific features for legacy compatibility, local reference wrapping, and integrated Boost serialization.
+
+## Table of Contents
+1. [Overview](#overview)
+2. [Key Differences from std::shared_ptr](#key-differences-from-stdshared_ptr)
+3. [Common Usage](#common-usage)
+4. [Construction and Assignment](#construction-and-assignment)
+5. [Wrapping References](#wrapping-references)
+6. [Polymorphism and Casting](#polymorphism-and-casting)
+7. [Serialization](#serialization)
+8. [Thread Safety](#thread-safety)
+
+---
+
+## Overview
+
+A `SmartPointer` manages the lifetime of an object through reference counting. When the last `SmartPointer` owning an object is destroyed or reset, the object is automatically deleted (unless a custom deleter is provided).
+
+The implementation uses an internal `ControlBlock` to manage the reference count and an optional deleter function.
+
+## Key Differences from std::shared_ptr
+
+| Feature | `uLib::SmartPointer<T>` | `std::shared_ptr<T>` |
+| :--- | :--- | :--- |
+| **Default Constructor** | Initializes to `nullptr`. | Initializes to `nullptr`. |
+| **Implicit Conversion** | Implicitly converts from `T*` and to `T*`. | Explicit construction from `T*`, no implicit conversion to `T*`. |
+| **Reference Wrapping** | Direct support for wrapping `T&` with a no-op deleter. | Requires explicit custom deleter `[](T*){}`. |
+| **Serialization** | Built-in Boost.Serialization support. | Requires external serialization helpers. |
+
+> [!NOTE]
+> The default constructor `SmartPointer<T>()` now initializes to `nullptr`, matching standard C++ smart pointer behavior.
+
+## Common Usage
+
+```cpp
+#include "Core/SmartPointer.h"
+
+// 1. Allocation via default constructor (Allocates a new MyObject)
+uLib::SmartPointer<MyObject> ptr; 
+
+// 2. Explicit null pointer
+uLib::SmartPointer<MyObject> null_ptr(nullptr);
+
+// 3. From raw pointer
+uLib::SmartPointer<MyObject> manual_ptr(new MyObject(args));
+
+// 4. Accessing members
+ptr->DoSomething();
+(*ptr).Value = 10;
+
+// 5. Checking validity
+if (ptr) {
+    // ...
+}
+```
+
+## Construction and Assignment
+
+### Allocation and Ownership
+- `SmartPointer()`: Initializes to `nullptr` (Standard behavior).
+- `SmartPointer(nullptr)`: Initializes to null.
+- `SmartPointer(T* ptr)`: Takes ownership of the raw pointer (implicit conversion allowed).
+- `SmartPointer(T& ref)`: Wraps an existing reference with a no-op deleter (implicit conversion allowed).
+- `SmartPointer(T* ptr, Deleter d)`: Takes ownership and uses a custom deleter.
+- `SmartPointer(const SmartPointer* other)`: Creates a copy from a *pointer* to another `SmartPointer`.
+
+### Move and Copy
+- Supports standard copy and move semantics. Move operations transfer ownership without incrementing the reference count.
+
+### Pointer Access
+- `get()` / `Get()`: Returns the underlying raw pointer.
+- `operator T*()`: Implicit conversion to raw pointer (legacy support).
+
+## Wrapping References
+
+The `SmartPointer` can wrap an existing object (e.g., on the stack) without taking ownership:
+
+```cpp
+MyObject stackObj;
+uLib::SmartPointer<MyObject> spt(stackObj); 
+// spt will NOT delete stackObj when it goes out of scope.
+```
+
+## Polymorphism and Casting
+
+`SmartPointer` supports assignment between compatible types (base/derived). For explicit casting, use the following utilities:
+
+- `uLib::static_pointer_cast<T>(ptr)`
+- `uLib::dynamic_pointer_cast<T>(ptr)`
+- `uLib::const_pointer_cast<T>(ptr)`
+- `uLib::reinterpret_pointer_cast<T>(ptr)`
+
+Example:
+```cpp
+uLib::SmartPointer<Derived> derived(new Derived());
+uLib::SmartPointer<Base> base = derived; // Automatic upcast
+
+auto derived2 = uLib::dynamic_pointer_cast<Derived>(base); // Downcast
+```
+
+## Serialization
+
+`SmartPointer` is fully integrated with `boost::serialization`. It tracks `ControlBlock` identity during serialization to ensure that multiple shared pointers to the same object are correctly reconstructed as a single shared instance.
+
+```cpp
+#include <boost/archive/text_oarchive.hpp>
+
+void save(const uLib::SmartPointer<MyObject>& ptr, std::ostream& os) {
+    boost::archive::text_oarchive oa(os);
+    oa << ptr;
+}
+```
+
+## Thread Safety
+
+- The reference count is managed using `std::atomic<uint32_t>`, making the increment/decrement operations thread-safe.
+- **Note**: While the reference counter itself is thread-safe, the object pointed to by the `SmartPointer` is not automatically protected. Standard thread-safety rules for the underlying type `T` apply.
+- Multiple threads can read the same `SmartPointer` concurrently. Concurrent modification (assignment/reset) of the *same* `SmartPointer` instance by different threads requires external synchronization.

src/Core/SmartPointer.h

@@ -60,8 +60,7 @@ private:
 /**
  * @brief A smart pointer implementation inspired by std::shared_ptr.
  */
-template <typename T>
-class SmartPointer {
+template <typename T> class SmartPointer {
 public:
     using element_type = T;
 
@@ -91,11 +90,7 @@ public:
         }
     };
 
-    SmartPointer() : m_counter(nullptr) {
-        if constexpr (std::is_default_constructible_v<T>) {
-            m_counter = new ReferenceCounter(new T());
-        }
-    }
+    SmartPointer() noexcept : m_counter(nullptr) {}
 
     SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
 
@@ -234,13 +229,26 @@ private:
     }
 };
 
-template <typename T, typename U> SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, static_cast<T*>(r.get())); }
-template <typename T, typename U> SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U>& r) noexcept { 
+template <typename T, typename U> 
+SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept { 
+    return SmartPointer<T>(r, static_cast<T*>(r.get())); 
+}
+
+template <typename T, typename U> 
+SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U>& r) noexcept { 
     if (auto p = dynamic_cast<T*>(r.get())) return SmartPointer<T>(r, p);
     return SmartPointer<T>(nullptr);
 }
-template <typename T, typename U> SmartPointer<T> const_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, const_cast<T*>(r.get())); }
-template <typename T, typename U> SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, reinterpret_cast<T*>(r.get())); }
+
+template <typename T, typename U> 
+SmartPointer<T> const_pointer_cast(const SmartPointer<U>& r) noexcept { 
+    return SmartPointer<T>(r, const_cast<T*>(r.get())); 
+}
+
+template <typename T, typename U> 
+SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U>& r) noexcept { 
+    return SmartPointer<T>(r, reinterpret_cast<T*>(r.get())); 
+}
 
 } // namespace uLib
 

src/Core/testing/SerializeTest.cpp

@@ -214,7 +214,7 @@ int test_referece_serialization() {
 }
 
 int test_referece_smartpointer_serialization() {
-  SmartPointer<A> a;
+  SmartPointer<A> a(new A());
   a->init_properties();
   {
     C c, c2; c.m_a = a; c2.m_a = a; 

src/Core/testing/SmartPointerTest.cpp

@@ -74,15 +74,10 @@ int main () {
         TEST1(test_smpt(spt));
     }
 
+    // TEST NULL POINTER //
     {
         SmartPointer<Test::ObjectMock> spt;
-        TEST1(test_smpt(spt));
-    }
-
-    {
-        SmartPointer<Test::ObjectMock> base_spt;
-        SmartPointer<Test::ObjectMock> spt = &base_spt;
-        TEST1(test_smpt(spt));
+        TEST1(!spt);
     }
 
     // TAKE REFERENCE //
@@ -115,5 +110,27 @@ int main () {
       TEST1(spt4->Value() == 101112);
     }
 
+    {
+      SmartPointer<Test::ObjectMock> spt = new Test::ObjectMock;
+      spt->Value() = 12345;
+      TEST1(spt->Value() == 12345);
+      
+      SmartPointer<Test::ObjectMock> spt2 = spt;
+      TEST1(spt2->Value() == 12345);
+      TEST1(spt.use_count() == 2);
+    }
+
+    {
+      // Using new with custom deleter
+      bool deleted = false;
+      {
+        SmartPointer<int> spt(new int(10), [&](int* p) {
+          deleted = true;
+          delete p;
+        });
+        TEST1(*spt == 10);
+      }
+      TEST1(deleted == true);
+    }
     END_TESTING;
 }

src/Math/testing/VoxImageTest.cpp

@@ -89,17 +89,31 @@ int main() {
   }
 
   {
-    VoxImage<TestVoxel> img(Vector3i(4, 4, 4));
+    const int size = 100;
+    VoxImage<TestVoxel> img(Vector3i(size, size, size));
     img.InitVoxels({0.f, 0});
-    for (int i = 0; i < 4; i++) {
-      for (int j = 0; j < 4; j++) {
-        for (int k = 0; k < 4; k++) {
+    for (int i = 0; i < size; i++) {
+      for (int j = 0; j < size; j++) {
+        for (int k = 0; k < size; k++) {
           img[Vector3i(i, j, k)] = {static_cast<float>(i + j + k), 0};
         }
       }
     }
-    img.ExportToVti("./vti_saved.vti", 0, 1);
-    // img.ImportFromVtkXml("./test_vox_image.vti");
+    img.ExportToVti("./vti_saved.vti", 0, true); // compressed
+
+    VoxImage<TestVoxel> imgR(Vector3i(0, 0, 0));
+    imgR.ImportFromVti("./vti_saved.vti", 0);
+    TEST1(img.GetDims() == imgR.GetDims());
+    TEST1(img.GetSpacing() == imgR.GetSpacing());
+    TEST1(img.GetOrigin() == imgR.GetOrigin());
+    TEST1(img.GetPosition() == imgR.GetPosition());
+    for (int i = 0; i < size; i++) {
+      for (int j = 0; j < size; j++) {
+        for (int k = 0; k < size; k++) {
+          TEST1(img[Vector3i(i, j, k)].Value == imgR[Vector3i(i, j, k)].Value);
+        }
+      }
+    }
   }
 
   {

src/Vtk/Math/testing/vtkAssemblyTest.cpp

@@ -9,96 +9,101 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+#include "Vtk/Math/vtkAssembly.h"
+#include "Math/Units.h"
 #include "Vtk/Math/vtkAssembly.h"
 #include "Vtk/Math/vtkContainerBox.h"
 #include "Vtk/Math/vtkCylinder.h"
-#include "Vtk/Math/vtkAssembly.h"
-#include "Vtk/vtkObjectsContext.h"
 #include "Vtk/uLibVtkViewer.h"
-#include "Math/Units.h"
+#include "Vtk/vtkObjectsContext.h"
 
 #include <vtkActor.h>
-#include <vtkProperty.h>
 #include <vtkPropCollection.h>
+#include <vtkProperty.h>
 
 #include <iostream>
 
 using namespace uLib;
 
 int main(int argc, char **argv) {
-    bool interactive = (argc > 1 && std::string(argv[1]) == "-i");
+  bool interactive = (argc > 1 && std::string(argv[1]) == "-i");
 
-    // ---- 1. Build model objects ----
-    ContainerBox box1;
-    box1.Scale(Vector3f(1_m, 2_m, 0.5_m));
-    box1.SetPosition(Vector3f(0, 0, 0));
+  // ---- 1. Build model objects ----
+  ContainerBox box1;
+  box1.Scale(Vector3f(1_m, 2_m, 0.5_m));
+  box1.SetPosition(Vector3f(0, 0, 0));
 
-    ContainerBox box2;
-    box2.Scale(Vector3f(0.5_m, 0.5_m, 3_m));
-    box2.SetPosition(Vector3f(2_m, 0, 0));
+  ContainerBox box2;
+  box2.Scale(Vector3f(0.5_m, 0.5_m, 3_m));
+  box2.SetPosition(Vector3f(2_m, 0, 0));
 
-    Cylinder cyl(0.3_m, 1.5_m, 1);
-    cyl.SetPosition(Vector3f(0, 3_m, 0));
+  Cylinder cyl(0.3_m, 1.5_m, 1);
+  cyl.SetPosition(Vector3f(0, 3_m, 0));
 
-    // ---- 2. Create an Assembly and add objects ----
-    Assembly assembly;
-    assembly.AddObject(&box1);
-    assembly.AddObject(&box2);
-    assembly.AddObject(&cyl);
-    assembly.SetShowBoundingBox(true);
+  // ---- 2. Create an Assembly and add objects ----
+  Assembly assembly;
+  assembly.AddObject(&box1);
+  assembly.AddObject(&box2);
+  assembly.AddObject(&cyl);
+  assembly.SetShowBoundingBox(true);
 
-    // ---- 3. Apply a group transform ----
-    assembly.SetPosition(Vector3f(1_m, 1_m, 0));
+  // ---- 3. Apply a group transform ----
+  assembly.SetPosition(Vector3f(1_m, 1_m, 0));
 
-    // ---- 5. Visualize (create prop3ds to set properties) ----
-    Vtk::Assembly vtkAsm(&assembly);
+  // ---- 5. Visualize (create prop3ds to set properties) ----
+  Vtk::Assembly vtkAsm(&assembly);
 
-    Vtk::Viewer viewer;
-    vtkAsm.AddToViewer(viewer); // This triggers prop3d creation via ConnectRenderer which eventually calls Prop3D::GetProp
-    
-    // Explicitly update to ensure prop3ds exist and are added to assemblies
-    vtkAsm.Update();
+  Vtk::Viewer viewer;
+  vtkAsm.AddToViewer(
+      viewer); // This triggers prop3d creation via ConnectRenderer which
+               // eventually calls Prop3D::GetProp
 
-    // Use the child context to find child prop3ds and set colors
-    if (auto* childCtx = vtkAsm.GetChildrenContext()) {
-        auto setProps = [](Vtk::Prop3D* p, float r, float g, float b) {
-            if (!p) return;
-            vtkPropCollection* props = p->GetProps();
-            props->InitTraversal();
-            for (int i=0; i < props->GetNumberOfItems(); ++i) {
-                if (auto* actor = vtkActor::SafeDownCast(props->GetNextProp())) {
-                    actor->GetProperty()->SetColor(r, g, b);
-                    actor->GetProperty()->SetRepresentationToSurface();
-                    actor->GetProperty()->SetOpacity(0.5);
-                }
-            }
-        };
+  // Explicitly update to ensure prop3ds exist and are added to assemblies
+  vtkAsm.Update();
 
-        setProps(childCtx->GetProp3D(&box1), 1.0, 0.0, 0.0); // Red
-        setProps(childCtx->GetProp3D(&box2), 0.0, 1.0, 0.0); // Green
-        setProps(childCtx->GetProp3D(&cyl),  0.0, 0.0, 1.0); // Blue
-    }
+  // Use the child context to find child prop3ds and set colors
+  if (auto *childCtx = vtkAsm.GetChildrenContext()) {
+    auto setProps = [](Vtk::Prop3D *p, float r, float g, float b) {
+      if (!p)
+        return;
+      vtkPropCollection *props = p->GetProps();
+      props->InitTraversal();
+      for (int i = 0; i < props->GetNumberOfItems(); ++i) {
+        if (auto *actor = vtkActor::SafeDownCast(props->GetNextProp())) {
+          actor->GetProperty()->SetColor(r, g, b);
+          actor->GetProperty()->SetRepresentationToSurface();
+          actor->GetProperty()->SetOpacity(0.5);
+        }
+      }
+    };
 
-    std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
+    setProps(childCtx->GetProp3D(&box1), 1.0, 0.0, 0.0); // Red
+    setProps(childCtx->GetProp3D(&box2), 0.0, 1.0, 0.0); // Green
+    setProps(childCtx->GetProp3D(&cyl), 0.0, 0.0, 1.0);  // Blue
+  }
 
-    // ---- 4. Query the bounding box for terminal output ----
-    Vector3f bbMin, bbMax;
-    assembly.GetBoundingBox(bbMin, bbMax);
-    std::cout << "Assembly bounding box:" << std::endl;
-    std::cout << "  min = " << bbMin.transpose() << std::endl;
-    std::cout << "  max = " << bbMax.transpose() << std::endl;
+  std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size()
+            << " (Expected 4: 1 assembly + 3 children)" << std::endl;
 
-    std::cout << "==================================================\n";
-    std::cout << " vtkAssemblyTest\n";
-    std::cout << " 2 boxes + 1 cylinder grouped in an assembly\n";
-    std::cout << "==================================================" << std::endl;
+  // ---- 4. Query the bounding box for terminal output ----
+  Vector3f bbMin, bbMax;
+  assembly.GetBoundingBox(bbMin, bbMax);
+  std::cout << "Assembly bounding box:" << std::endl;
+  std::cout << "  min = " << bbMin.transpose() << std::endl;
+  std::cout << "  max = " << bbMax.transpose() << std::endl;
 
-    if (interactive) {
-        viewer.ZoomAuto();
-        viewer.Start();
-    } else {
-        std::cout << "Non-interactive test passed." << std::endl;
-    }
+  std::cout << "==================================================\n";
+  std::cout << " vtkAssemblyTest\n";
+  std::cout << " 2 boxes + 1 cylinder grouped in an assembly\n";
+  std::cout << "=================================================="
+            << std::endl;
 
-    return 0;
+  if (interactive) {
+    viewer.ZoomAuto();
+    viewer.Start();
+  } else {
+    std::cout << "Non-interactive test passed." << std::endl;
+  }
+
+  return 0;
 }

src/Vtk/Math/testing/vtkContainerBoxTest.cpp

@@ -35,20 +35,17 @@ using namespace uLib;
 int main() {
   BEGIN_TESTING(vtk ContainerBox Test);
 
-  {
-    ContainerBox* box = new ContainerBox();
-    box->Scale(Vector3f(1_m, 2_m, 1_m));
-    box->SetPosition(Vector3f(0, 0, 0));
+  ContainerBox* box = new ContainerBox();
+  box->SetSize(Vector3f(1_m, 2_m, 1_m));
+  box->SetPosition(Vector3f(0, 0, 0));
 
-    Vtk::ContainerBox v_box(box);
-    v_box.Update();
+  Vtk::ContainerBox v_box(box);
+  v_box.Update();
 
-    v_box.SetRepresentation(Vtk::Prop3D::Surface);
-    v_box.SetOpacity(0.5);
-    v_box.SetSelectable(true);
-  }
+  v_box.SetRepresentation(Vtk::Prop3D::Surface);
+  v_box.SetOpacity(0.5);
+  v_box.SetSelectable(true);
 
-  Vtk::ContainerBox v_box;
   v_box.findOrAddSignal(&Object::Updated)->connect([&v_box]() {
     std::cout << "box updated: "
               << v_box.GetWrapped()->GetWorldPoint(HPoint3f(1, 1, 1)) << std::endl;

src/Vtk/Math/testing/vtkVoxImageInteractiveTest.cpp

@@ -59,9 +59,9 @@ int main(int argc, char **argv) {
 
   // --- Image 1: Spherical Shell ---
   Vector3i dims1(64, 64, 64);
-  VoxImage<Voxel> img1(dims1);
-  img1.SetSpacing(Vector3f(1.0, 1.0, 1.0));
-  img1.SetPosition(Vector3f(-40, -32, -32));
+  VoxImage<Voxel>* img1 = new VoxImage<Voxel>(dims1);
+  img1->SetSpacing(Vector3f(1.0, 1.0, 1.0));
+  img1->SetPosition(Vector3f(-40, -32, -32));
 
   for (int z = 0; z < dims1(2); ++z) {
     for (int y = 0; y < dims1(1); ++y) {
@@ -76,16 +76,16 @@ int main(int argc, char **argv) {
         } else {
           v.Value = 0.0f;
         }
-        img1[Vector3i(x, y, z)] = v;
+        img1->operator[](Vector3i(x, y, z)) = v;
       }
     }
   }
 
   // --- Image 2: Axes Gradient ---
   Vector3i dims2(64, 64, 64);
-  VoxImage<Voxel> img2(dims2);
-  img2.SetSpacing(Vector3f(1.0, 1.0, 1.0));
-  img2.SetPosition(Vector3f(40, -32, -32));
+  VoxImage<Voxel>* img2 = new VoxImage<Voxel>(dims2);
+  img2->SetSpacing(Vector3f(1.0, 1.0, 1.0));
+  img2->SetPosition(Vector3f(40, -32, -32));
 
   for (int z = 0; z < dims2(2); ++z) {
     for (int y = 0; y < dims2(1); ++y) {
@@ -96,15 +96,15 @@ int main(int argc, char **argv) {
             (float(x) / dims2(0) + float(y) / dims2(1) + float(z) / dims2(2)) /
             3.0f;
         v.Value = (40.0f * val) / factor;
-        img2[Vector3i(x, y, z)] = v;
+        img2->operator[](Vector3i(x, y, z)) = v;
       }
     }
   }
 
-  Vtk::VoxImage vtk_img1(&img1);
+  Vtk::VoxImage vtk_img1(img1);
   vtk_img1.setShadingPreset(0);
 
-  Vtk::VoxImage vtk_img2(&img2);
+  Vtk::VoxImage vtk_img2(img2);
   vtk_img2.setShadingPreset(1); // Use Composite without MIP for variety
 
   Vtk::Viewer viewer;

src/Vtk/Math/testing/vtkVoxImageTest.cpp

@@ -40,12 +40,12 @@ BOOST_AUTO_TEST_CASE(vtkVoxImageConstruction) {
   TestVoxel zero = {0, 0};
   TestVoxel nonzero = {5.5f * 1e-6f, 100};
 
-  VoxImage<TestVoxel> img(Vector3i(10, 10, 10));
-  img.SetSpacing(Vector3f(3, 3, 3));
-  img.InitVoxels(zero);
-  img[Vector3i(3, 3, 3)] = nonzero;
+  VoxImage<TestVoxel>* img = new VoxImage<TestVoxel>(Vector3i(10, 10, 10));
+  img->SetSpacing(Vector3f(3, 3, 3));
+  img->InitVoxels(zero);
+  (*img)[Vector3i(3, 3, 3)] = nonzero;
 
-  Vtk::VoxImage vtk_img(&img);
+  Vtk::VoxImage vtk_img(img);
   vtk_img.SaveToXMLFile("test_vtkvoximage.vti");
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {

src/Vtk/Math/vtkAssembly.cpp

@@ -44,6 +44,10 @@ Assembly::Assembly(uLib::Assembly *content)
 }
 
 Assembly::~Assembly() {
+    if (this->m_model) {
+        Object::disconnect(this->m_model.get(), &uLib::Assembly::Updated,
+                          this, &Assembly::Update);
+    }
     delete m_ChildContext;
     if (m_BBoxActor)  m_BBoxActor->Delete();
     if (m_VtkAsm)     m_VtkAsm->Delete();

src/Vtk/Math/vtkContainerBox.cpp

@@ -38,6 +38,8 @@
 #include <vtkMatrix4x4.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
+#include <vtkRenderWindow.h>
+#include <vtkRendererCollection.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 
@@ -50,25 +52,33 @@ struct ContainerBoxData {
   vtkSmartPointer<vtkActor> m_Cube;
   vtkSmartPointer<vtkActor> m_Axes;
   vtkSmartPointer<vtkAssembly> m_VtkAsm;
+  vtkSmartPointer<vtkCubeSource> m_CubeSource;
+  vtkSmartPointer<vtkAxes> m_AxesSource;
   uLib::Connection m_UpdateSignal;
 
   ContainerBoxData()
       : m_Cube(vtkSmartPointer<vtkActor>::New()),
         m_Axes(vtkSmartPointer<vtkActor>::New()),
-        m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()) {}
-  ~ContainerBoxData() {}
+        m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()),
+        m_CubeSource(vtkSmartPointer<vtkCubeSource>::New()),
+        m_AxesSource(vtkSmartPointer<vtkAxes>::New()) {}
 };
 
-ContainerBox::ContainerBox(ContainerBox::Content *content)
-    : d(new ContainerBoxData()),
-      ObjectWrapper(content ? content : new Content()) {
+ContainerBox::ContainerBox(uLib::ContainerBox *model)
+    : Prop3D(), d(new ContainerBoxData()) {
+  this->m_model.reset(model);
   this->InstallPipe();
+
   d->m_UpdateSignal = Object::connect(
       this->m_model.get(), &uLib::Object::Updated, this, &ContainerBox::Update);
-      this->Update();
+  this->Update();
 }
 
-ContainerBox::~ContainerBox() { delete d; }
+ContainerBox::~ContainerBox() {
+  uLib::Object::disconnect(this->m_model.get(), &uLib::Object::Updated, this,
+                           &ContainerBox::Update);
+  delete d;
+}
 
 vtkPolyData *ContainerBox::GetPolyData() const {
   // TODO
@@ -80,22 +90,35 @@ void ContainerBox::Update() {
   if (!this->m_model)
     return;
 
-  vtkProp3D *prop = vtkProp3D::SafeDownCast(this->GetProp());
-  if (prop) {
-    // Apply the TRS matrix to the assembly
-    vtkNew<vtkMatrix4x4> m;
-    Matrix4fToVtk(this->m_model->GetMatrix(), m);
-    prop->SetUserMatrix(m);
-    prop->Modified();
-  }
+  // Update the sources with the model's dimensions.
+  // This makes the "natural" bounds of the actors correct for VTK gizmos.
+  Vector3f size = this->m_model->GetSize();
+  Vector3f origin = this->m_model->GetOrigin();
 
-  // Apply the local shape transformation (Size/Origin) to the cube actor
-  vtkNew<vtkMatrix4x4> localM;
-  Matrix4fToVtk(this->m_model->GetLocalMatrix(), localM);
-  d->m_Cube->SetUserMatrix(localM);
+  // HandlerWidget relies on vtkProp3D::GetBounds() to determine the size
+  // and position of its transformation gizmos. Previously, we were applying
+  // the Size of the container using the actor's UserMatrix. While this looks
+  // correct visually, some VTK utilities (including certain internal paths
+  // of GetBounds()) may prioritize the bounding box of the input geometry
+  // (the PolyData) over the UserMatrix. This resulted in the gizmo defaulting
+  // to a 1x1x1 size because the underlying vtkCubeSource was still 1x1x1.
 
-  // Delegate rest of update (appearance, render, etc)
-  ConnectionBlock blocker(d->m_UpdateSignal);
+  d->m_CubeSource->SetBounds(origin.x(), origin.x() + size.x(), origin.y(),
+                             origin.y() + size.y(), origin.z(),
+                             origin.z() + size.z());
+  d->m_CubeSource->Update();
+
+  d->m_AxesSource->SetOrigin(origin.x(), origin.y(), origin.z());
+  d->m_AxesSource->SetScaleFactor(std::max({size.x(), size.y(), size.z()}));
+  d->m_AxesSource->Update();
+
+  // Ensure actors have identity UserMatrix since scaling is in the source.
+  d->m_Cube->SetUserMatrix(nullptr);
+  d->m_Axes->SetUserMatrix(nullptr);
+
+  // Delegate the rest of the update (appearance, TR, render, etc) to Prop3D.
+  // Prop3D::Update() applies the "outer" TRS matrix (Position/Rotation/Scaling)
+  // to the assembly.
   this->Prop3D::Update();
 }
 
@@ -104,66 +127,35 @@ void ContainerBox::SyncFromVtk() {
   if (!this->m_model)
     return;
 
-  vtkProp3D *root = this->GetProxyProp();
-  if (!root)
-    return;
-
-  // VTK -> Model: Extract new world TRS from proxy, which matches the model's
-  // TRS center
-  vtkMatrix4x4 *rootMat = root->GetUserMatrix();
-  Matrix4f vtkWorld = VtkToMatrix4f(rootMat);
-
-  // Synchronize TRS property members from the updated local matrix
-  this->m_model->FromMatrix(vtkWorld);
-
-  // Since we modified the model, notify observers, but block the loop back to
-  // VTK ConnectionBlock blocker(d->m_UpdateSignal);
-  this->m_model->Updated();
+  // Sync the "outer" TRS from the assembly's matrix
+  this->Prop3D::SyncFromVtk();
 }
 
 void ContainerBox::InstallPipe() {
   if (!this->m_model)
     return;
-  Content *c = this->m_model;
 
-  // CUBE
+  vtkSmartPointer<vtkPolyDataMapper> mapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
 
-  vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-  vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
-
-  // cube->SetBounds(-0.5, 0.5, -0.5, 0.5, -0.5, 0.5);
-  mapper->SetInputConnection(cube->GetOutputPort());
-  mapper->Update();
+  // CUBE //
+  mapper->SetInputConnection(d->m_CubeSource->GetOutputPort());
   d->m_Cube->SetMapper(mapper);
   d->m_Cube->GetProperty()->SetRepresentationToWireframe();
   d->m_Cube->GetProperty()->SetAmbient(0.7);
 
   // AXES //
-  vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
-  axes->SetOrigin(0, 0, 0);
   mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-  mapper->SetInputConnection(axes->GetOutputPort());
-  mapper->Update();
+  mapper->SetInputConnection(d->m_AxesSource->GetOutputPort());
   d->m_Axes->SetMapper(mapper);
   d->m_Axes->GetProperty()->SetLineWidth(3);
   d->m_Axes->GetProperty()->SetAmbient(0.4);
   d->m_Axes->GetProperty()->SetSpecular(0);
 
-  // PIVOT //
-  axes = vtkSmartPointer<vtkAxes>::New();
-  axes->SetOrigin(0, 0, 0);
-  mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-  mapper->SetInputConnection(axes->GetOutputPort());
-  mapper->Update();
-
   d->m_VtkAsm->AddPart(d->m_Cube);
   d->m_VtkAsm->AddPart(d->m_Axes);
   this->SetProp(d->m_VtkAsm);
 
-  // vtkProp3D* root = d->m_VtkAsm;
-  // if (root) {
-  //     this->ApplyProp3DTransform(root);
-  // }
   this->Update();
 }
 

src/Vtk/vtkObjectsContext.cpp

@@ -36,6 +36,12 @@ ObjectsContext::ObjectsContext(uLib::ObjectsContext *context)
 }
 
 ObjectsContext::~ObjectsContext() {
+  if (m_Context) {
+    Object::disconnect(m_Context, &uLib::ObjectsContext::ObjectAdded, this,
+                      &ObjectsContext::OnObjectAdded);
+    Object::disconnect(m_Context, &uLib::ObjectsContext::ObjectRemoved, this,
+                      &ObjectsContext::OnObjectRemoved);
+  }
   for (auto const &[obj, prop3d] : m_Prop3Ds) {
     delete prop3d;
   }