feat: add Boost serialization support for SmartPointer and include standard smart pointer headers

docs/object_context.md

@@ -2,15 +2,7 @@
 
 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. 
+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. 
-
-## 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

@@ -1,120 +0,0 @@
-# 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

@@ -29,32 +29,34 @@
 #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>
 
 namespace uLib {
 
 /**
- * @brief Internal control block for shared ownership across polymorphic SmartPointers.
+ * @brief Internal control block for shared ownership across polymorphic
+ * SmartPointers.
  */
 struct ControlBlock {
-    std::atomic<uint32_t> count;
+  std::atomic<uint32_t> count;
-    std::function<void()> deleter;
+  std::function<void()> deleter;
 
-    explicit ControlBlock(uint32_t initial_count = 1) : count(initial_count) {}
+  explicit ControlBlock(uint32_t initial_count = 1) : count(initial_count) {}
 
 private:
-    friend class boost::serialization::access;
+  friend class boost::serialization::access;
-    template <class Archive>
+  template <class Archive>
-    void serialize(Archive& ar, const unsigned int /*version*/) {
+  void serialize(Archive &ar, const unsigned int /*version*/) {
-        // ControlBlock identity is tracked by Boost via the cb pointer in ReferenceCounter.
+    // ControlBlock identity is tracked by Boost via the cb pointer in
-        // We only save the count value.
+    // ReferenceCounter. We only save the count value.
-        uint32_t c = count.load();
+    uint32_t c = count.load();
-        ar & boost::serialization::make_nvp("count", c);
+    ar &boost::serialization::make_nvp("count", c);
-        if constexpr (Archive::is_loading::value) count.store(c);
+    if constexpr (Archive::is_loading::value)
-    }
+      count.store(c);
+  }
 };
 
 /**
@@ -62,192 +64,238 @@ private:
  */
 template <typename T> class SmartPointer {
 public:
-    using element_type = T;
+  using element_type = T;
 
-    /**
+  /**
-     * @brief Nested reference counter structure. 
+   * @brief Nested reference counter structure.
-     * Preserved as a nested template for Boost serialization compatibility.
+   * Preserved as a nested template for Boost serialization compatibility.
-     */
+   */
-    struct ReferenceCounter {
+  struct ReferenceCounter {
-        T* ptr;
+    T *ptr;
-        ControlBlock* cb;
+    ControlBlock *cb;
 
-        ReferenceCounter() : ptr(nullptr), cb(nullptr) {}
+    ReferenceCounter() : ptr(nullptr), cb(nullptr) {}
-        explicit ReferenceCounter(T* p) : ptr(p), cb(new ControlBlock(1)) {
+    explicit ReferenceCounter(T *p) : ptr(p), cb(new ControlBlock(1)) {
-            cb->deleter = [p]() { delete p; };
+      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); };
-        }
-
-    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 (Implicit conversion allowed for legacy compatibility).
-     */
-    SmartPointer(T* ptr) : m_counter(nullptr) {
-        if (ptr) m_counter = new ReferenceCounter(ptr);
     }
-
     template <typename D>
-    SmartPointer(T* ptr, D deleter) : m_counter(nullptr) {
+    ReferenceCounter(T *p, D d) : ptr(p), cb(new ControlBlock(1)) {
-        if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
+      cb->deleter = [p, d]() { d(p); };
     }
 
-    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){})) { }
+  private:
-
+    friend class boost::serialization::access;
-    SmartPointer(const SmartPointer& other) noexcept : m_counter(nullptr) {
-        acquire(other.m_counter);
-    }
-
-    SmartPointer(const SmartPointer* other) noexcept : m_counter(nullptr) {
-        if (other) acquire(other->m_counter);
-    }
-
-    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;
-    }
-
-    ~SmartPointer() { release(); }
-
-    SmartPointer& operator=(const SmartPointer& other) noexcept {
-        if (this != &other) {
-            release();
-            acquire(other.m_counter);
-        }
-        return *this;
-    }
-
-    SmartPointer& operator=(T* ptr) noexcept {
-        reset(ptr);
-        return *this;
-    }
-
-    SmartPointer& operator=(SmartPointer&& other) noexcept {
-        if (this != &other) {
-            release();
-            m_counter = other.m_counter;
-            other.m_counter = nullptr;
-        }
-        return *this;
-    }
-
-    void reset(T* ptr = nullptr) {
-        release();
-        if (ptr) m_counter = new ReferenceCounter(ptr);
-    }
-
-    void swap(SmartPointer& other) noexcept {
-        std::swap(m_counter, other.m_counter);
-    }
-
-    T& operator*() const noexcept { return *(m_counter->ptr); }
-    T* operator->() const noexcept { return m_counter->ptr; }
-    T* get() const noexcept { return m_counter ? m_counter->ptr : nullptr; }
-    T* Get() const noexcept { return get(); }
-    operator T*() const noexcept { return get(); }
-
-    uint32_t use_count() const noexcept {
-        return (m_counter && m_counter->cb) ? m_counter->cb->count.load(std::memory_order_relaxed) : 0;
-    }
-
-    bool unique() const noexcept { return use_count() == 1; }
-    explicit operator bool() const noexcept { return get() != nullptr; }
-
-    BOOST_SERIALIZATION_SPLIT_MEMBER()
-
     template <class Archive>
-    void save(Archive& ar, const unsigned int /*version*/) const {
+    void serialize(Archive &ar, const unsigned int /*version*/) {
-        ar & boost::serialization::make_nvp("counter", m_counter);
+      ar &boost::serialization::make_nvp("ptr", ptr);
+      ar &boost::serialization::make_nvp("cb", cb);
     }
+  };
 
-    template <class Archive>
+  SmartPointer() : m_counter(nullptr) {
-    void load(Archive& ar, const unsigned int /*version*/) {
+    if constexpr (std::is_default_constructible_v<T>) {
-        release();
+      m_counter = new ReferenceCounter(new T());
-        ar & boost::serialization::make_nvp("counter", m_counter);
-        if (m_counter && m_counter->cb) {
-            m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
-        }
     }
+  }
+
+  SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
+
+  /**
+   * @brief Constructor from raw pointer (Implicit conversion allowed for legacy
+   * compatibility).
+   */
+  SmartPointer(T *ptr) : m_counter(nullptr) {
+    if (ptr)
+      m_counter = new ReferenceCounter(ptr);
+  }
+
+  template <typename D> SmartPointer(T *ptr, D deleter) : m_counter(nullptr) {
+    if (ptr)
+      m_counter = new ReferenceCounter(ptr, deleter);
+  }
+
+  SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T *) {})) {}
+
+  SmartPointer(const SmartPointer &other) noexcept : m_counter(nullptr) {
+    acquire(other.m_counter);
+  }
+
+  SmartPointer(const SmartPointer *other) noexcept : m_counter(nullptr) {
+    if (other)
+      acquire(other->m_counter);
+  }
+
+  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;
+  }
+
+  ~SmartPointer() { release(); }
+
+  SmartPointer &operator=(const SmartPointer &other) noexcept {
+    if (this != &other) {
+      release();
+      acquire(other.m_counter);
+    }
+    return *this;
+  }
+
+  SmartPointer &operator=(T *ptr) noexcept {
+    reset(ptr);
+    return *this;
+  }
+
+  SmartPointer &operator=(SmartPointer &&other) noexcept {
+    if (this != &other) {
+      release();
+      m_counter = other.m_counter;
+      other.m_counter = nullptr;
+    }
+    return *this;
+  }
+
+  void reset(T *ptr = nullptr) {
+    release();
+    if (ptr)
+      m_counter = new ReferenceCounter(ptr);
+  }
+
+  void swap(SmartPointer &other) noexcept {
+    std::swap(m_counter, other.m_counter);
+  }
+
+  T &operator*() const noexcept { return *(m_counter->ptr); }
+  T *operator->() const noexcept { return m_counter->ptr; }
+  T *get() const noexcept { return m_counter ? m_counter->ptr : nullptr; }
+  T *Get() const noexcept { return get(); }
+  operator T *() const noexcept { return get(); }
+
+  uint32_t use_count() const noexcept {
+    return (m_counter && m_counter->cb)
+               ? m_counter->cb->count.load(std::memory_order_relaxed)
+               : 0;
+  }
+
+  bool unique() const noexcept { return use_count() == 1; }
+  explicit operator bool() const noexcept { return get() != nullptr; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archive>
+  void save(Archive &ar, const unsigned int /*version*/) const {
+    ar &boost::serialization::make_nvp("counter", m_counter);
+  }
+
+  template <class Archive>
+  void load(Archive &ar, const unsigned int /*version*/) {
+    release();
+    ar &boost::serialization::make_nvp("counter", m_counter);
+    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;
+
+  template <class Archive>
+  void serialize(Archive &ar, const unsigned int /*version*/) {
+    if (Archive::is_loading::value) {
+      release();
+    }
+    ar &boost::serialization::make_nvp("counter", m_counter);
+    if (Archive::is_loading::value && m_counter) {
+      m_counter->count.fetch_add(1, std::memory_order_relaxed);
+    }
+  }
+
+  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>
-    ReferenceCounter* m_counter;
+    void serialize(Archive &ar, const unsigned int /*version*/) {
-
+      ar &boost::serialization::make_nvp("ptr", ptr);
-    void acquire(ReferenceCounter* c) noexcept {
-        if (c) {
-            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 {
+  ReferenceCounter *m_counter;
-        if (m_counter) {
+
-            if (m_counter->cb && m_counter->cb->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+  void acquire(ReferenceCounter *c) noexcept {
-                if (m_counter->cb->deleter) m_counter->cb->deleter();
+    m_counter = c;
-                delete m_counter->cb;
+    if (c) {
-            }
+      c->count.fetch_add(1, std::memory_order_relaxed);
-            delete m_counter;
-            m_counter = nullptr;
-        }
     }
+  }
+
+  void release() noexcept {
+    if (m_counter) {
+      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;
+    }
+  }
 };
 
-template <typename T, typename U> 
+template <typename T, typename U>
-SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept { 
+SmartPointer<T> static_pointer_cast(const SmartPointer<U> &r) noexcept {
-    return SmartPointer<T>(r, static_cast<T*>(r.get())); 
+  return SmartPointer<T>(r, static_cast<T *>(r.get()));
 }
-
+template <typename T, typename U>
-template <typename T, typename U> 
+SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U> &r) noexcept {
-SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U>& r) noexcept { 
+  if (auto p = dynamic_cast<T *>(r.get()))
-    if (auto p = dynamic_cast<T*>(r.get())) return SmartPointer<T>(r, p);
+    return SmartPointer<T>(r, p);
-    return SmartPointer<T>(nullptr);
+  return SmartPointer<T>(nullptr);
 }
-
+template <typename T, typename U>
-template <typename T, typename U> 
+SmartPointer<T> const_pointer_cast(const SmartPointer<U> &r) noexcept {
-SmartPointer<T> const_pointer_cast(const SmartPointer<U>& r) noexcept { 
+  return SmartPointer<T>(r, const_cast<T *>(r.get()));
-    return SmartPointer<T>(r, const_cast<T*>(r.get())); 
 }
-
+template <typename T, typename U>
-template <typename T, typename U> 
+SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U> &r) noexcept {
-SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U>& r) noexcept { 
+  return SmartPointer<T>(r, reinterpret_cast<T *>(r.get()));
-    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(new A());
+  SmartPointer<A> a;
   a->init_properties();
   {
     C c, c2; c.m_a = a; c2.m_a = a; 

src/Core/testing/SmartPointerTest.cpp

@@ -74,10 +74,15 @@ int main () {
         TEST1(test_smpt(spt));
     }
 
-    // TEST NULL POINTER //
     {
         SmartPointer<Test::ObjectMock> spt;
-        TEST1(!spt);
+        TEST1(test_smpt(spt));
+    }
+
+    {
+        SmartPointer<Test::ObjectMock> base_spt;
+        SmartPointer<Test::ObjectMock> spt = &base_spt;
+        TEST1(test_smpt(spt));
     }
 
     // TAKE REFERENCE //
@@ -110,27 +115,5 @@ 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,31 +89,17 @@ int main() {
   }
 
   {
-    const int size = 100;
+    VoxImage<TestVoxel> img(Vector3i(4, 4, 4));
-    VoxImage<TestVoxel> img(Vector3i(size, size, size));
     img.InitVoxels({0.f, 0});
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < 4; i++) {
-      for (int j = 0; j < size; j++) {
+      for (int j = 0; j < 4; j++) {
-        for (int k = 0; k < size; k++) {
+        for (int k = 0; k < 4; k++) {
           img[Vector3i(i, j, k)] = {static_cast<float>(i + j + k), 0};
         }
       }
     }
-    img.ExportToVti("./vti_saved.vti", 0, true); // compressed
+    img.ExportToVti("./vti_saved.vti", 0, 1);
-
+    // img.ImportFromVtkXml("./test_vox_image.vti");
-    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,101 +9,96 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-#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/uLibVtkViewer.h"
+#include "Vtk/Math/vtkAssembly.h"
 #include "Vtk/vtkObjectsContext.h"
+#include "Vtk/uLibVtkViewer.h"
+#include "Math/Units.h"
 
 #include <vtkActor.h>
-#include <vtkPropCollection.h>
 #include <vtkProperty.h>
+#include <vtkPropCollection.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 ----
+    // ---- 1. Build model objects ----
-  ContainerBox box1;
+    ContainerBox box1;
-  box1.Scale(Vector3f(1_m, 2_m, 0.5_m));
+    box1.Scale(Vector3f(1_m, 2_m, 0.5_m));
-  box1.SetPosition(Vector3f(0, 0, 0));
+    box1.SetPosition(Vector3f(0, 0, 0));
 
-  ContainerBox box2;
+    ContainerBox box2;
-  box2.Scale(Vector3f(0.5_m, 0.5_m, 3_m));
+    box2.Scale(Vector3f(0.5_m, 0.5_m, 3_m));
-  box2.SetPosition(Vector3f(2_m, 0, 0));
+    box2.SetPosition(Vector3f(2_m, 0, 0));
 
-  Cylinder cyl(0.3_m, 1.5_m, 1);
+    Cylinder cyl(0.3_m, 1.5_m, 1);
-  cyl.SetPosition(Vector3f(0, 3_m, 0));
+    cyl.SetPosition(Vector3f(0, 3_m, 0));
 
-  // ---- 2. Create an Assembly and add objects ----
+    // ---- 2. Create an Assembly and add objects ----
-  Assembly assembly;
+    Assembly assembly;
-  assembly.AddObject(&box1);
+    assembly.AddObject(&box1);
-  assembly.AddObject(&box2);
+    assembly.AddObject(&box2);
-  assembly.AddObject(&cyl);
+    assembly.AddObject(&cyl);
-  assembly.SetShowBoundingBox(true);
+    assembly.SetShowBoundingBox(true);
 
-  // ---- 3. Apply a group transform ----
+    // ---- 3. Apply a group transform ----
-  assembly.SetPosition(Vector3f(1_m, 1_m, 0));
+    assembly.SetPosition(Vector3f(1_m, 1_m, 0));
 
-  // ---- 5. Visualize (create prop3ds to set properties) ----
+    // ---- 5. Visualize (create prop3ds to set properties) ----
-  Vtk::Assembly vtkAsm(&assembly);
+    Vtk::Assembly vtkAsm(&assembly);
 
-  Vtk::Viewer viewer;
+    Vtk::Viewer viewer;
-  vtkAsm.AddToViewer(
+    vtkAsm.AddToViewer(viewer); // This triggers prop3d creation via ConnectRenderer which eventually calls Prop3D::GetProp
-      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();
 
-  // Explicitly update to ensure prop3ds exist and are added to assemblies
+    // Use the child context to find child prop3ds and set colors
-  vtkAsm.Update();
+    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);
+                }
+            }
+        };
 
-  // Use the child context to find child prop3ds and set colors
+        setProps(childCtx->GetProp3D(&box1), 1.0, 0.0, 0.0); // Red
-  if (auto *childCtx = vtkAsm.GetChildrenContext()) {
+        setProps(childCtx->GetProp3D(&box2), 0.0, 1.0, 0.0); // Green
-    auto setProps = [](Vtk::Prop3D *p, float r, float g, float b) {
+        setProps(childCtx->GetProp3D(&cyl),  0.0, 0.0, 1.0); // Blue
-      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);
-        }
-      }
-    };
 
-    setProps(childCtx->GetProp3D(&box1), 1.0, 0.0, 0.0); // Red
+    std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
-    setProps(childCtx->GetProp3D(&box2), 0.0, 1.0, 0.0); // Green
-    setProps(childCtx->GetProp3D(&cyl), 0.0, 0.0, 1.0);  // Blue
-  }
 
-  std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size()
+    // ---- 4. Query the bounding box for terminal output ----
-            << " (Expected 4: 1 assembly + 3 children)" << std::endl;
+    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;
 
-  // ---- 4. Query the bounding box for terminal output ----
+    std::cout << "==================================================\n";
-  Vector3f bbMin, bbMax;
+    std::cout << " vtkAssemblyTest\n";
-  assembly.GetBoundingBox(bbMin, bbMax);
+    std::cout << " 2 boxes + 1 cylinder grouped in an assembly\n";
-  std::cout << "Assembly bounding box:" << std::endl;
+    std::cout << "==================================================" << std::endl;
-  std::cout << "  min = " << bbMin.transpose() << std::endl;
-  std::cout << "  max = " << bbMax.transpose() << std::endl;
 
-  std::cout << "==================================================\n";
+    if (interactive) {
-  std::cout << " vtkAssemblyTest\n";
+        viewer.ZoomAuto();
-  std::cout << " 2 boxes + 1 cylinder grouped in an assembly\n";
+        viewer.Start();
-  std::cout << "=================================================="
+    } else {
-            << std::endl;
+        std::cout << "Non-interactive test passed." << std::endl;
+    }
 
-  if (interactive) {
+    return 0;
-    viewer.ZoomAuto();
-    viewer.Start();
-  } else {
-    std::cout << "Non-interactive test passed." << std::endl;
-  }
-
-  return 0;
 }

src/Vtk/Math/testing/vtkContainerBoxTest.cpp

@@ -35,17 +35,20 @@ using namespace uLib;
 int main() {
   BEGIN_TESTING(vtk ContainerBox Test);
 
-  ContainerBox* box = new ContainerBox();
+  {
-  box->SetSize(Vector3f(1_m, 2_m, 1_m));
+    ContainerBox* box = new ContainerBox();
-  box->SetPosition(Vector3f(0, 0, 0));
+    box->Scale(Vector3f(1_m, 2_m, 1_m));
+    box->SetPosition(Vector3f(0, 0, 0));
 
-  Vtk::ContainerBox v_box(box);
+    Vtk::ContainerBox v_box(box);
-  v_box.Update();
+    v_box.Update();
 
-  v_box.SetRepresentation(Vtk::Prop3D::Surface);
+    v_box.SetRepresentation(Vtk::Prop3D::Surface);
-  v_box.SetOpacity(0.5);
+    v_box.SetOpacity(0.5);
-  v_box.SetSelectable(true);
+    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 = new VoxImage<Voxel>(dims1);
+  VoxImage<Voxel> img1(dims1);
-  img1->SetSpacing(Vector3f(1.0, 1.0, 1.0));
+  img1.SetSpacing(Vector3f(1.0, 1.0, 1.0));
-  img1->SetPosition(Vector3f(-40, -32, -32));
+  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->operator[](Vector3i(x, y, z)) = v;
+        img1[Vector3i(x, y, z)] = v;
       }
     }
   }
 
   // --- Image 2: Axes Gradient ---
   Vector3i dims2(64, 64, 64);
-  VoxImage<Voxel>* img2 = new VoxImage<Voxel>(dims2);
+  VoxImage<Voxel> img2(dims2);
-  img2->SetSpacing(Vector3f(1.0, 1.0, 1.0));
+  img2.SetSpacing(Vector3f(1.0, 1.0, 1.0));
-  img2->SetPosition(Vector3f(40, -32, -32));
+  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->operator[](Vector3i(x, y, z)) = v;
+        img2[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 = new VoxImage<TestVoxel>(Vector3i(10, 10, 10));
+  VoxImage<TestVoxel> img(Vector3i(10, 10, 10));
-  img->SetSpacing(Vector3f(3, 3, 3));
+  img.SetSpacing(Vector3f(3, 3, 3));
-  img->InitVoxels(zero);
+  img.InitVoxels(zero);
-  (*img)[Vector3i(3, 3, 3)] = nonzero;
+  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,10 +44,6 @@ 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,8 +38,6 @@
 #include <vtkMatrix4x4.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
-#include <vtkRenderWindow.h>
-#include <vtkRendererCollection.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 
@@ -52,33 +50,25 @@ 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()),
+        m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()) {}
-        m_CubeSource(vtkSmartPointer<vtkCubeSource>::New()),
+  ~ContainerBoxData() {}
-        m_AxesSource(vtkSmartPointer<vtkAxes>::New()) {}
 };
 
-ContainerBox::ContainerBox(uLib::ContainerBox *model)
+ContainerBox::ContainerBox(ContainerBox::Content *content)
-    : Prop3D(), d(new ContainerBoxData()) {
+    : d(new ContainerBoxData()),
-  this->m_model.reset(model);
+      ObjectWrapper(content ? content : new Content()) {
   this->InstallPipe();
-
   d->m_UpdateSignal = Object::connect(
       this->m_model.get(), &uLib::Object::Updated, this, &ContainerBox::Update);
-  this->Update();
+      this->Update();
 }
 
-ContainerBox::~ContainerBox() {
+ContainerBox::~ContainerBox() { delete d; }
-  uLib::Object::disconnect(this->m_model.get(), &uLib::Object::Updated, this,
-                           &ContainerBox::Update);
-  delete d;
-}
 
 vtkPolyData *ContainerBox::GetPolyData() const {
   // TODO
@@ -90,35 +80,22 @@ void ContainerBox::Update() {
   if (!this->m_model)
     return;
 
-  // Update the sources with the model's dimensions.
+  vtkProp3D *prop = vtkProp3D::SafeDownCast(this->GetProp());
-  // This makes the "natural" bounds of the actors correct for VTK gizmos.
+  if (prop) {
-  Vector3f size = this->m_model->GetSize();
+    // Apply the TRS matrix to the assembly
-  Vector3f origin = this->m_model->GetOrigin();
+    vtkNew<vtkMatrix4x4> m;
+    Matrix4fToVtk(this->m_model->GetMatrix(), m);
+    prop->SetUserMatrix(m);
+    prop->Modified();
+  }
 
-  // HandlerWidget relies on vtkProp3D::GetBounds() to determine the size
+  // Apply the local shape transformation (Size/Origin) to the cube actor
-  // and position of its transformation gizmos. Previously, we were applying
+  vtkNew<vtkMatrix4x4> localM;
-  // the Size of the container using the actor's UserMatrix. While this looks
+  Matrix4fToVtk(this->m_model->GetLocalMatrix(), localM);
-  // correct visually, some VTK utilities (including certain internal paths
+  d->m_Cube->SetUserMatrix(localM);
-  // 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.
 
-  d->m_CubeSource->SetBounds(origin.x(), origin.x() + size.x(), origin.y(),
+  // Delegate rest of update (appearance, render, etc)
-                             origin.y() + size.y(), origin.z(),
+  ConnectionBlock blocker(d->m_UpdateSignal);
-                             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();
 }
 
@@ -127,35 +104,66 @@ void ContainerBox::SyncFromVtk() {
   if (!this->m_model)
     return;
 
-  // Sync the "outer" TRS from the assembly's matrix
+  vtkProp3D *root = this->GetProxyProp();
-  this->Prop3D::SyncFromVtk();
+  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();
 }
 
 void ContainerBox::InstallPipe() {
   if (!this->m_model)
     return;
+  Content *c = this->m_model;
 
-  vtkSmartPointer<vtkPolyDataMapper> mapper =
+  // CUBE
-      vtkSmartPointer<vtkPolyDataMapper>::New();
 
-  // CUBE //
+  vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-  mapper->SetInputConnection(d->m_CubeSource->GetOutputPort());
+  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();
   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(d->m_AxesSource->GetOutputPort());
+  mapper->SetInputConnection(axes->GetOutputPort());
+  mapper->Update();
   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,12 +36,6 @@ 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;
   }