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

.agents/rules/micromamba_build.md

@@ -18,7 +18,7 @@ This rule provides instructions for building the uLib project using the micromam
    ```bash
    export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
    export MAMBA_ROOT_PREFIX="/home/share/micromamba"
-   export PRESET="clang-make"
+   export PRESET="clang-debug"
    eval "$(${MAMBA_EXE} shell hook --shell bash)"
    micromamba activate uLib
    ```

app/gcompose/src/ContextModel.cpp

@@ -38,8 +38,8 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
         });
 
         // Connect existing objects
-        for (auto* obj : m_rootContext->GetObjects()) {
-            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+        for (const auto& obj : m_rootContext->GetObjects()) {
+            uLib::Object::connect(obj.get(), &uLib::Object::Updated, refresh);
         }
     }
     endResetModel();
@@ -229,8 +229,8 @@ bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, in
         [&findAndRemoveRecursive](uLib::Object* current, uLib::Object* target) {
         if (auto ctx = current->GetChildren()) {
             ctx->RemoveObject(target);
-            for (auto* obj : ctx->GetObjects()) {
-                findAndRemoveRecursive(obj, target);
+            for (const auto& obj : ctx->GetObjects()) {
+                findAndRemoveRecursive(obj.get(), target);
             }
         }
     };
@@ -245,9 +245,9 @@ bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, in
              std::function<bool(uLib::Object*, uLib::Object*)> isDescendant = 
                 [&isDescendant](uLib::Object* root, uLib::Object* target) -> bool {
                   if (auto ctx = root->GetChildren()) {
-                     for (auto* child : ctx->GetObjects()) {
-                         if (child == target) return true;
-                         if (isDescendant(child, target)) return true;
+                      for (const auto& child : ctx->GetObjects()) {
+                          if (child.get() == target) return true;
+                          if (isDescendant(child.get(), target)) return true;
                       }
                   }
                  return false;

app/gcompose/src/MainPanel.cpp

@@ -182,8 +182,8 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
 
             // Add any prop3ds that were created during m_mainVtkContext's construction to all panes
             auto panes = this->findChildren<ViewportPane*>();
-            for (auto* obj : context->GetObjects()) {
-                if (auto* p = m_mainVtkContext->GetProp3D(obj)) {
+            for (const auto& obj : context->GetObjects()) {
+                if (auto* p = m_mainVtkContext->GetProp3D(obj.get())) {
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
                             vp->AddProp3D(*p);

app/gcompose/src/PropertyWidgets.cpp

@@ -426,15 +426,15 @@ void ReferencePropertyWidget::refreshCombo() {
 
     if (m_Context) {
         const auto& objects = m_Context->GetObjects();
-        for (auto* obj : objects) {
-            if (m_RefProp->IsCompatible(obj)) {
+        for (const auto& obj : objects) {
+            if (m_RefProp->IsCompatible(obj.get())) {
                 QString label = QString::fromStdString(obj->GetInstanceName());
                 if (label.isEmpty()) {
                     label = QString::fromStdString(std::string(obj->GetClassName()));
                 }
                 // Add index suffix if name is empty to disambiguate
-                m_Combo->addItem(label, QVariant::fromValue((quintptr)obj));
-                if (obj == currentRef) {
+                m_Combo->addItem(label, QVariant::fromValue((quintptr)obj.get()));
+                if (obj.get() == currentRef) {
                     selectedIdx = m_Combo->count() - 1;
                 }
             }

docs/object_context.md

@@ -2,6 +2,24 @@
 
 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 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
+
+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 that is derived from uLib::Object. It is a smart pointer because it will automatically delete the object when it is no longer needed. It is also a smart pointer because it will automatically update the object when it is no longer needed. 
+
+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 the context is destroyed.
+For this reason the access to a object context for a Object via Get/Set is done using the SmartPointer instances. 
+
+
 ## Geant Physical Volumes
 
 The Geant library add a further layer of complexity. The physical volumes are created from a what is called LogicalVolume (which holds information about the shape, material and daughter volumes) and represent the actual instances of the volumes in the detector. So in this sense they represent what could be the Prop3D in the uLib Vtk library. The PhysicalVolume is created from the LogicalVolume and is the one that is actually placed in the scene, with its own relative TRS: position and rotation (rotation here is a rotation matrix comprising the scaling). 

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/ObjectsContext.cpp

@@ -8,28 +8,41 @@ ObjectsContext::ObjectsContext() : Object() {}
 ObjectsContext::~ObjectsContext() {}
 
 void ObjectsContext::AddObject(Object* obj) {
-    if (obj && std::find(m_objects.begin(), m_objects.end(), obj) == m_objects.end()) {
-        m_objects.push_back(obj);
+    if (obj) {
+        auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
+            return sp.get() == obj;
+        });
+        if (it == m_objects.end()) {
+            m_objects.push_back(SmartPointer<Object>(obj));
             // Connect child's update to context's update to trigger re-renders
             Object::connect(obj, &Object::Updated, this, &Object::Updated);
             ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
             this->Updated(); // Signal that the context has been updated
         }
+    }
 }
 
 void ObjectsContext::RemoveObject(Object* obj) {
-    auto it = std::find(m_objects.begin(), m_objects.end(), obj);
+    auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
+        return sp.get() == obj;
+    });
     if (it != m_objects.end()) {
-        Object* removedObj = *it;
-        m_objects.erase(it);
+        Object* removedObj = it->get();
+        // Since we are about to erase it from the vector, if it was the last reference
+        // it would be deleted. We might want to emit the signal BEFORE erasing.
         ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, removedObj);
+        m_objects.erase(it);
         this->Updated(); // Signal that the context has been updated
     }
 }
 
 void ObjectsContext::Clear() {
     if (!m_objects.empty()) {
-        for (auto obj : m_objects) {
+        // Create a copy of the pointers to emit signals since m_objects might be modified or cleared
+        std::vector<Object*> toRemove;
+        for (const auto& sp : m_objects) toRemove.push_back(sp.get());
+
+        for (auto obj : toRemove) {
             ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
         }
         m_objects.clear();
@@ -37,7 +50,7 @@ void ObjectsContext::Clear() {
     }
 }
 
-const std::vector<Object*>& ObjectsContext::GetObjects() const {
+const std::vector<SmartPointer<Object>>& ObjectsContext::GetObjects() const {
     return m_objects;
 }
 
@@ -47,7 +60,7 @@ size_t ObjectsContext::GetCount() const {
 
 Object* ObjectsContext::GetObject(size_t index) const {
     if (index < m_objects.size()) {
-        return m_objects[index];
+        return m_objects[index].get();
     }
     return nullptr;
 }

src/Core/ObjectsContext.h

@@ -2,6 +2,7 @@
 #define U_CORE_OBJECTS_CONTEXT_H
 
 #include "Core/Object.h"
+#include "Core/SmartPointer.h"
 #include <vector>
 
 namespace uLib {
@@ -36,9 +37,9 @@ public:
 
     /**
      * @brief Returns the collection of objects.
-     * @return Const reference to the vector of object pointers.
+     * @return Const reference to the vector of SmartPointer<Object>.
      */
-    const std::vector<Object*>& GetObjects() const;
+    const std::vector<SmartPointer<Object>>& GetObjects() const;
     
     signals:
     /** @brief Signal emitted when an object is added. */
@@ -60,7 +61,7 @@ public:
     Object* GetObject(size_t index) const;
 
 private:
-    std::vector<Object*> m_objects;
+    std::vector<SmartPointer<Object>> m_objects;
 };
 
 } // namespace uLib

src/Core/SmartPointer.h

@@ -3,7 +3,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
   Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
+  All Padua preserved
 
   Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
 
@@ -29,96 +29,119 @@
 #include <atomic>
 #include <functional>
 #include <type_traits>
-#include <utility>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/vector.hpp>
-#include <boost/serialization/string.hpp>
 
 #include <boost/serialization/access.hpp>
 #include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
 
 namespace uLib {
 
 /**
- * @brief A smart pointer implementation inspired by std::shared_ptr.
- * 
- * Features modernized C++11/14/17 syntax, thread-safe reference counting,
- * move semantics, and support for custom deleters.
- * 
- * NOTE: Default constructor allocates a new T following legacy behavior.
+ * @brief Internal control block for shared ownership across polymorphic SmartPointers.
  */
-template <typename T>
-class SmartPointer {
+struct ControlBlock {
+    std::atomic<uint32_t> count;
+    std::function<void()> deleter;
+
+    explicit ControlBlock(uint32_t initial_count = 1) : count(initial_count) {}
+
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int /*version*/) {
+        // ControlBlock identity is tracked by Boost via the cb pointer in ReferenceCounter.
+        // We only save the count value.
+        uint32_t c = count.load();
+        ar & boost::serialization::make_nvp("count", c);
+        if constexpr (Archive::is_loading::value) count.store(c);
+    }
+};
+
+/**
+ * @brief A smart pointer implementation inspired by std::shared_ptr.
+ */
+template <typename T> class SmartPointer {
 public:
     using element_type = T;
 
     /**
-     * @brief Default constructor.
-     * Allocates a new T following legacy behavior.
+     * @brief Nested reference counter structure. 
+     * Preserved as a nested template for Boost serialization compatibility.
      */
-    SmartPointer() : m_counter(nullptr) {
-        if constexpr (std::is_default_constructible_v<T>) {
-            m_counter = new ReferenceCounter(new T());
+    struct ReferenceCounter {
+        T* ptr;
+        ControlBlock* cb;
+
+        ReferenceCounter() : ptr(nullptr), cb(nullptr) {}
+        explicit ReferenceCounter(T* p) : ptr(p), cb(new ControlBlock(1)) {
+            cb->deleter = [p]() { delete p; };
         }
+        template <typename D>
+        ReferenceCounter(T* p, D d) : ptr(p), cb(new ControlBlock(1)) {
+            cb->deleter = [p, d]() { d(p); };
         }
 
-    /**
-     * @brief Constructor from nullptr.
-     */
+    private:
+        friend class boost::serialization::access;
+        template <class Archive>
+        void serialize(Archive& ar, const unsigned int /*version*/) {
+            ar & boost::serialization::make_nvp("ptr", ptr);
+            ar & boost::serialization::make_nvp("cb", cb);
+        }
+    };
+
+    SmartPointer() noexcept : m_counter(nullptr) {}
+
     SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
 
     /**
-     * @brief Constructor from raw pointer.
+     * @brief Constructor from raw pointer (Implicit conversion allowed for legacy compatibility).
      */
-    explicit SmartPointer(T* ptr) : m_counter(nullptr) {
+    SmartPointer(T* ptr) : m_counter(nullptr) {
         if (ptr) m_counter = new ReferenceCounter(ptr);
     }
 
-    /**
-     * @brief Constructor with custom deleter.
-     */
     template <typename D>
     SmartPointer(T* ptr, D deleter) : m_counter(nullptr) {
         if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
     }
 
-    /**
-     * @brief Non-owning constructor from reference.
-     * Uses a no-op deleter to ensure the referenced object is not destroyed.
-     */
-    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){}, 1)) { }
+    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){})) { }
 
-    /**
-     * @brief Copy constructor.
-     */
     SmartPointer(const SmartPointer& other) noexcept : m_counter(nullptr) {
         acquire(other.m_counter);
     }
 
-    /**
-     * @brief Copy constructor from a pointer to SmartPointer (Legacy support).
-     */
     SmartPointer(const SmartPointer* other) noexcept : m_counter(nullptr) {
         if (other) acquire(other->m_counter);
     }
 
-    /**
-     * @brief Move constructor.
-     */
+    template <typename U, typename = std::enable_if_t<std::is_convertible_v<U*, T*>>>
+    SmartPointer(const SmartPointer<U>& other) noexcept : m_counter(nullptr) {
+        if (other.m_counter) {
+            m_counter = new ReferenceCounter();
+            m_counter->ptr = static_cast<T*>(other.m_counter->ptr);
+            m_counter->cb = other.m_counter->cb;
+            if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
+        }
+    }
+
+    template <typename U>
+    SmartPointer(const SmartPointer<U>& other, T* ptr) noexcept : m_counter(nullptr) {
+        if (other.m_counter) {
+            m_counter = new ReferenceCounter();
+            m_counter->ptr = ptr;
+            m_counter->cb = other.m_counter->cb;
+            if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
+        }
+    }
+
     SmartPointer(SmartPointer&& other) noexcept : m_counter(other.m_counter) {
         other.m_counter = nullptr;
     }
 
-    /**
-     * @brief Virtual destructor.
-     */
-    virtual ~SmartPointer() { release(); }
+    ~SmartPointer() { release(); }
 
-    /**
-     * @brief Copy assignment.
-     */
     SmartPointer& operator=(const SmartPointer& other) noexcept {
         if (this != &other) {
             release();
@@ -132,9 +155,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Move assignment.
-     */
     SmartPointer& operator=(SmartPointer&& other) noexcept {
         if (this != &other) {
             release();
@@ -144,66 +164,26 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Resets the smart pointer to hold a new raw pointer.
-     */
     void reset(T* ptr = nullptr) {
         release();
         if (ptr) m_counter = new ReferenceCounter(ptr);
     }
 
-    /**
-     * @brief Resets the smart pointer with a custom deleter.
-     */
-    template <typename D>
-    void reset(T* ptr, D deleter) {
-        release();
-        if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
-    }
-
-    /**
-     * @brief Swaps contents with another SmartPointer.
-     */
     void swap(SmartPointer& other) noexcept {
         std::swap(m_counter, other.m_counter);
     }
 
-    /**
-     * @brief Dereference operator.
-     */
-    T& operator*() const noexcept { return *m_counter->ptr; }
-
-    /**
-     * @brief Member access operator.
-     */
+    T& operator*() const noexcept { return *(m_counter->ptr); }
     T* operator->() const noexcept { return m_counter->ptr; }
-
-    /**
-     * @brief Returns the raw pointer.
-     */
     T* get() const noexcept { return m_counter ? m_counter->ptr : nullptr; }
     T* Get() const noexcept { return get(); }
-
-    /**
-     * @brief Implicit conversion to raw pointer (legacy compatibility).
-     */
     operator T*() const noexcept { return get(); }
 
-    /**
-     * @brief Returns the number of SmartPointers sharing ownership.
-     */
     uint32_t use_count() const noexcept {
-        return m_counter ? m_counter->count.load(std::memory_order_relaxed) : 0;
+        return (m_counter && m_counter->cb) ? m_counter->cb->count.load(std::memory_order_relaxed) : 0;
     }
 
-    /**
-     * @brief Returns true if this is the only SmartPointer owning the resource.
-     */
     bool unique() const noexcept { return use_count() == 1; }
-
-    /**
-     * @brief Boolean conversion operator.
-     */
     explicit operator bool() const noexcept { return get() != nullptr; }
 
     BOOST_SERIALIZATION_SPLIT_MEMBER()
@@ -217,104 +197,57 @@ public:
     void load(Archive& ar, const unsigned int /*version*/) {
         release();
         ar & boost::serialization::make_nvp("counter", m_counter);
-        if (m_counter) {
-            m_counter->count.fetch_add(1, std::memory_order_relaxed);
+        if (m_counter && m_counter->cb) {
+            m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
         }
     }
 
 private:
+    template <typename U> friend class SmartPointer;
     friend class boost::serialization::access;
 
-    struct ReferenceCounter {
-        T* ptr;
-        std::atomic<uint32_t> count;
-        std::function<void(T*)> deleter;
-
-        ReferenceCounter(T* p, uint32_t initial_count = 1)
-            : ptr(p), count(initial_count), deleter([](T* ptr_to_del) { delete ptr_to_del; }) {}
-
-        template <typename D>
-        ReferenceCounter(T* p, D d, uint32_t initial_count = 1)
-            : ptr(p), count(initial_count), deleter(d) {}
-
-        ReferenceCounter() 
-            : ptr(nullptr), count(0), deleter([](T* p) { delete p; }) {}
-
-    private:
-        friend class boost::serialization::access;
-        template <class Archive>
-        void serialize(Archive& ar, const unsigned int /*version*/) {
-            ar & boost::serialization::make_nvp("ptr", ptr);
-        }
-    };
-
     ReferenceCounter* m_counter;
 
     void acquire(ReferenceCounter* c) noexcept {
-        m_counter = c;
         if (c) {
-            c->count.fetch_add(1, std::memory_order_relaxed);
+            m_counter = new ReferenceCounter();
+            m_counter->ptr = c->ptr;
+            m_counter->cb = c->cb;
+            if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
         }
     }
 
     void release() noexcept {
         if (m_counter) {
-            if (m_counter->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-                if (m_counter->ptr) {
-                    m_counter->deleter(m_counter->ptr);
+            if (m_counter->cb && m_counter->cb->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+                if (m_counter->cb->deleter) m_counter->cb->deleter();
+                delete m_counter->cb;
             }
             delete m_counter;
-            }
             m_counter = nullptr;
         }
     }
 };
 
-/**
- * @brief Global swap for SmartPointer.
- */
-template <typename T>
-void swap(SmartPointer<T>& a, SmartPointer<T>& b) noexcept {
-    a.swap(b);
-}
-
-/**
- * @brief Equality comparison.
- */
 template <typename T, typename U> 
-bool operator==(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
-    return a.get() == b.get();
+SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept { 
+    return SmartPointer<T>(r, static_cast<T*>(r.get())); 
 }
 
-/**
- * @brief Inequality comparison.
- */
 template <typename T, typename U> 
-bool operator!=(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
-    return a.get() != b.get();
+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);
 }
 
-/**
- * @brief Comparison with nullptr.
- */
-template <typename T>
-bool operator==(const SmartPointer<T>& a, std::nullptr_t) noexcept {
-    return a.get() == 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>
-bool operator==(std::nullptr_t, const SmartPointer<T>& a) noexcept {
-    return a.get() == nullptr;
-}
-
-template <typename T>
-bool operator!=(const SmartPointer<T>& a, std::nullptr_t) noexcept {
-    return a.get() != nullptr;
-}
-
-template <typename T>
-bool operator!=(std::nullptr_t, const SmartPointer<T>& a) noexcept {
-    return a.get() != nullptr;
+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/AffinityTest.cpp

@@ -10,17 +10,52 @@
 
 using namespace uLib;
 
+std::vector<int> GetAvailableCpus() {
+    std::vector<int> available;
+#ifdef __linux__
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    if (sched_getaffinity(0, sizeof(cpu_set_t), &cpuset) == 0) {
+        for (int i = 0; i < CPU_SETSIZE; ++i) {
+            if (CPU_ISSET(i, &cpuset)) {
+                available.push_back(i);
+            }
+        }
+    }
+#endif
+    return available;
+}
+
+class TestThread : public Thread {
+public:
+    void Run() override {
+        Thread::Sleep(200);
+    }
+};
+
 void TestThreadAffinity() {
     std::cout << "Testing Thread Affinity..." << std::endl;
 #ifdef __linux__
-    Thread t;
+    auto available = GetAvailableCpus();
+    if (available.empty()) {
+        std::cout << "  No CPUs available for affinity test, skipping." << std::endl;
+        return;
+    }
+    int target_cpu = available[0];
+    std::cout << "  Using CPU " << target_cpu << std::endl;
+
+    TestThread t;
     t.Start();
-    t.SetAffinity(0); // Bind to CPU 0
+    t.SetAffinity(target_cpu); 
     
     cpu_set_t cpuset;
     CPU_ZERO(&cpuset);
-    pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
-    assert(CPU_ISSET(0, &cpuset));
+    int s = pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
+    if (s != 0) {
+        std::cerr << "Error: pthread_getaffinity_np failed with code " << s << std::endl;
+        assert(false);
+    }
+    assert(CPU_ISSET(target_cpu, &cpuset));
     
     t.Join();
     std::cout << "  Passed (Thread bound to CPU 0)." << std::endl;
@@ -32,9 +67,15 @@ void TestThreadAffinity() {
 void TestTeamAffinity() {
     std::cout << "Testing Team Affinity..." << std::endl;
 #ifdef __linux__
-#ifdef _OPENMP
+    auto available = GetAvailableCpus();
+    if (available.size() < 2) {
+        std::cout << "  Not enough CPUs available for Team affinity test, skipping." << std::endl;
+        return;
+    }
+    std::vector<int> cpus = {available[0], available[1]};
+    std::cout << "  Using CPUs " << cpus[0] << ", " << cpus[1] << std::endl;
+
     Team team(2);
-    std::vector<int> cpus = {0, 1};
     team.SetAffinity(cpus);
     
     // We check affinity inside a parallel region
@@ -48,7 +89,6 @@ void TestTeamAffinity() {
         assert(CPU_ISSET(expected_cpu, &cpuset));
     }
     std::cout << "  Passed (Team threads bound correctly)." << std::endl;
-#endif
 #else
     std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
 #endif

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

@@ -27,6 +27,7 @@
 
 
 #include <iostream>
+#include "Core/Object.h"
 #include "Core/SmartPointer.h"
 #include "testing-prototype.h"
 
@@ -34,12 +35,12 @@ using namespace uLib;
 
 namespace Test {
 
-struct ObjectMockInterface {
+struct ObjectMockInterface : public Object {
     virtual void PrintValue()=0;
     virtual int& Value()=0;
 };
 
-class ObjectMock : ObjectMockInterface {
+class ObjectMock : public ObjectMockInterface {
     int value;
 public:
     int& Value() { return value; }
@@ -72,13 +73,11 @@ int main () {
         SmartPointer<Test::ObjectMock> spt(new Test::ObjectMock);
         TEST1(test_smpt(spt));
     }
+
+    // TEST NULL POINTER //
     {
         SmartPointer<Test::ObjectMock> spt;
-        TEST1(test_smpt(spt));
-    }
-    {
-        SmartPointer<Test::ObjectMock> spt = new SmartPointer<Test::ObjectMock>;
-        TEST1(test_smpt(spt));
+        TEST1(!spt);
     }
 
     // TAKE REFERENCE //
@@ -88,7 +87,50 @@ int main () {
         TEST1(test_smpt(spt));
     }
 
+    {
+        Test::ObjectMock obj;
+        SmartPointer<Object> spt1 = obj;
+        SmartPointer<Test::ObjectMock> spt2 = obj;
+        SmartPointer<Test::ObjectMockInterface> spt = obj;
+    }
 
+    { 
+      Test::ObjectMock *obj = new Test::ObjectMock; 
+      SmartPointer<Test::ObjectMock> spt(obj); 
+      SmartPointer<Test::ObjectMock> spt2(spt); 
+      SmartPointer<Test::ObjectMock> spt3(spt); 
+      SmartPointer<Test::ObjectMock> spt4(spt2); 
+      spt->Value() = 123;
+      spt2->Value() = 456;
+      spt3->Value() = 789;
+      spt4->Value() = 101112;
+      TEST1(spt->Value() == 101112);
+      TEST1(spt2->Value() == 101112);
+      TEST1(spt3->Value() == 101112);
+      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/HEP/Geant/Solid.cpp

@@ -170,14 +170,6 @@ BoxSolid::BoxSolid(const char *name) :
     m_Solid(new G4Box(name, 1, 1, 1))
   {}
 
-BoxSolid::BoxSolid(const char *name, ContainerBox *box) : 
-    Solid(name),
-    m_ContainerBox(box),
-    m_Solid(new G4Box(name, 1, 1, 1)) {
-  if (box) Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
-  Update();
-}
-
 BoxSolid::BoxSolid(const char *name, SmartPointer<ContainerBox> box) : 
     Solid(name),
     m_ContainerBox(box),

src/HEP/Geant/Solid.h

@@ -96,9 +96,7 @@ public:
     return m_Logical ? m_Logical->GetName().c_str() : m_Name.c_str();
   }
 
-  void SetSolid(Solid *solid) { m_Solid = solid; }
   void SetSolid(SmartPointer<Solid> solid) { m_Solid = solid; }
-  void SetMaterial(Material *material) { m_Material = material; }
   void SetMaterial(SmartPointer<Material> material) { m_Material = material; }
   
   G4LogicalVolume* GetG4LogicalVolume() const { return m_Logical; }
@@ -210,7 +208,6 @@ public:
 
   BoxSolid();
   BoxSolid(const char *name);
-  BoxSolid(const char *name, ContainerBox *box);
   BoxSolid(const char *name, SmartPointer<ContainerBox> box);
   
   virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }

src/Math/Assembly.cpp

@@ -89,8 +89,8 @@ void Assembly::ComputeBoundingBox() {
     m_BBoxMin = Vector3f(inf, inf, inf);
     m_BBoxMax = Vector3f(-inf, -inf, -inf);
 
-    for (Object *obj : objects) {
-        if (auto *box = dynamic_cast<ContainerBox *>(obj)) {
+    for (const auto& obj : objects) {
+        if (auto *box = dynamic_cast<ContainerBox *>(obj.get())) {
             // ContainerBox: wm is matrix from unit cube [0,1] to local space
             // Since it is parented to 'this', GetMatrix() is sufficient.
             Matrix4f m = box->GetMatrix();
@@ -104,7 +104,7 @@ void Assembly::ComputeBoundingBox() {
                     m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
                 }
             }
-        } else if (auto *cyl = dynamic_cast<Cylinder *>(obj)) {
+        } else if (auto *cyl = dynamic_cast<Cylinder *>(obj.get())) {
             // Cylinder: centered [-1, 1] radial, [-0.5, 0.5] height
             Matrix4f m = cyl->GetMatrix();
             for (int i = 0; i < 8; ++i) {
@@ -117,7 +117,7 @@ void Assembly::ComputeBoundingBox() {
                     m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
                 }
             }
-        } else if (auto *subAsm = dynamic_cast<Assembly *>(obj)) {
+        } else if (auto *subAsm = dynamic_cast<Assembly *>(obj.get())) {
             // Recursive AABB for nested assemblies
             subAsm->ComputeBoundingBox();
             Vector3f subMin, subMax;

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,17 +9,17 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+#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>
 
@@ -54,19 +54,22 @@ int main(int argc, char **argv) {
   Vtk::Assembly vtkAsm(&assembly);
 
   Vtk::Viewer viewer;
-    vtkAsm.AddToViewer(viewer); // This triggers prop3d creation via ConnectRenderer which eventually calls Prop3D::GetProp
+  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();
 
   // 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();
+  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())) {
+      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);
@@ -79,7 +82,8 @@ int main(int argc, char **argv) {
     setProps(childCtx->GetProp3D(&cyl), 0.0, 0.0, 1.0);  // Blue
   }
 
-    std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
+  std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size()
+            << " (Expected 4: 1 assembly + 3 children)" << std::endl;
 
   // ---- 4. Query the bounding box for terminal output ----
   Vector3f bbMin, bbMax;
@@ -91,7 +95,8 @@ int main(int argc, char **argv) {
   std::cout << "==================================================\n";
   std::cout << " vtkAssemblyTest\n";
   std::cout << " 2 boxes + 1 cylinder grouped in an assembly\n";
-    std::cout << "==================================================" << std::endl;
+  std::cout << "=================================================="
+            << std::endl;
 
   if (interactive) {
     viewer.ZoomAuto();

src/Vtk/Math/testing/vtkContainerBoxTest.cpp

@@ -35,9 +35,8 @@ using namespace uLib;
 int main() {
   BEGIN_TESTING(vtk ContainerBox Test);
 
-  {
   ContainerBox* box = new ContainerBox();
-    box->Scale(Vector3f(1_m, 2_m, 1_m));
+  box->SetSize(Vector3f(1_m, 2_m, 1_m));
   box->SetPosition(Vector3f(0, 0, 0));
 
   Vtk::ContainerBox v_box(box);
@@ -46,9 +45,7 @@ int main() {
   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();
 }
 
-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;
   }
@@ -49,8 +55,8 @@ void ObjectsContext::Synchronize() {
   // 1. Identify objects to add and remove
   const auto &objects = m_Context->GetObjects();
   std::map<uLib::Object *, bool> currentObjects;
-  for (auto obj : objects)
-    currentObjects[obj] = true;
+  for (const auto& obj : objects)
+    currentObjects[obj.get()] = true;
 
   // Remove Prop3Ds for objects no longer in context
   for (auto it = m_Prop3Ds.begin(); it != m_Prop3Ds.end();) {
@@ -71,11 +77,11 @@ void ObjectsContext::Synchronize() {
   }
 
   // Add Prop3Ds for new objects
-  for (auto obj : objects) {
-    if (m_Prop3Ds.find(obj) == m_Prop3Ds.end()) {
-      Prop3D *prop3d = this->CreateProp3D(obj);
+  for (const auto& obj : objects) {
+    if (m_Prop3Ds.find(obj.get()) == m_Prop3Ds.end()) {
+      Prop3D *prop3d = this->CreateProp3D(obj.get());
       if (prop3d) {
-        m_Prop3Ds[obj] = prop3d;
+        m_Prop3Ds[obj.get()] = prop3d;
         if (auto *p3d = vtkProp3D::SafeDownCast(prop3d->GetProp()))
           m_Assembly->AddPart(p3d);
         this->Prop3DAdded(prop3d);