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
    ```

.agents/skills/object_context.md

@@ -0,0 +1,29 @@
+# Skill: Object Context & Scene Management
+
+Guidelines for managing the `uLib` object hierarchy, Geant4 volume instantiation, and Gcompose scene interaction.
+
+## 1. Object Creation & Context
+- **Factory Pattern**: Always use `ObjectFactory` to instantiate objects from the registry. Avoid direct `new` calls for domain objects to ensure proper metadata and property initialization.
+- **Context Ownership**: The `Context` is the source of truth. Every persistent object must be registered within the `Context` to participate in the tree hierarchy, property system, and serialization.
+
+## 2. Geant4: Logical vs. Physical Volumes
+In the Geant4/HEP domain, visibility and placement follow a strict two-tier hierarchy:
+- **LogicalVolume**: Defines **what** the object is (Solid/Shape, Material, and daughter volumes). It is a template and does **not** have a spatial position.
+- **PhysicalVolume**: Defines **where** and **how** an instance exists. It references a `LogicalVolume` and holds the **TRS** (Translation, Rotation Matrix/Scale).
+- **CRITICAL**: Adding a `Solid` or `LogicalVolume` to the scene is insufficient for visualization. To display an object in the VTK viewport, you **must**:
+    1. Define the `LogicalVolume`.
+    2. Instantiate a `PhysicalVolume` from that `LogicalVolume`.
+    3. Add the `PhysicalVolume` to the scene context and apply TRS transformations to it.
+
+## 3. Gcompose: Tree Hierarchy & Visualization
+- **3D Representations**: Objects with 3D actors are automatically wrapped in VTK representations (e.g., `vtkContainerBox`). Non-3D objects remain in the tree but have no viewport presence.
+- **Reference Handling**: 
+    - Internal object references (raw pointers or `SmartPointer`) are rendered as "virtual children" in the tree.
+    - **Instance Re-use**: One object can appear as a child under multiple parents if referenced multiple times; these are placeholders for the same underlying instance.
+- **Setting References**:
+    - **Property Selector**: Filter and select compatible types from the global context within the property editor.
+    - **Drag & Drop**: Drag an object from the tree and drop it onto a property field. The system automatically validates types and performs the necessary casting/assignment.
+
+## 4. Best Practices & Checks
+- **TRS Logic**: Always apply transformations to the `PhysicalVolume`. Changes to a `LogicalVolume` will affect all its instances but will not move them.
+- **Dependency Tracking**: Use the tree structure to identify shared references. Changing a property on a shared object affects all parent nodes that reference it.

.vscode/settings.json

@@ -1,13 +1,14 @@
 {
+    "clangd.path": "/home/share/micromamba/envs/uLib/bin/clangd",
     "clangd.fallbackFlags": [
         "-I/home/rigoni/devel/cmt/uLib/src",
-        "-isystem/home/share/micromamba/envs/mutom/include",
+        "-isystem/home/share/micromamba/envs/uLib/include",
-        "-isystem/home/share/micromamba/envs/mutom/include/eigen3",
+        "-isystem/home/share/micromamba/envs/uLib/include/eigen3",
-        "-isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include",
+        "-isystem/home/share/micromamba/envs/uLib/targets/x86_64-linux/include",
-        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
+        "-isystem/home/share/micromamba/envs/uLib/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
-        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
+        "-isystem/home/share/micromamba/envs/uLib/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
-        "-isystem/home/share/micromamba/envs/mutom/x86_64-conda-linux-gnu/sysroot/usr/include",
+        "-isystem/home/share/micromamba/envs/uLib/x86_64-conda-linux-gnu/sysroot/usr/include",
-        "--gcc-toolchain=/home/share/micromamba/envs/mutom",
+        "--gcc-toolchain=/home/share/micromamba/envs/uLib",
         "-D__host__=",
         "-D__device__=",
         "-D__global__=",
@@ -18,8 +19,8 @@
     ],
     "clangd.semanticHighlighting.enable": true,
     "clangd.arguments": [
-        "--compile-commands-dir=build",
+        "--compile-commands-dir=build/clang-make",
-        "--query-driver=/home/share/micromamba/envs/mutom/bin/*",
+        "--query-driver=/home/share/micromamba/envs/uLib/bin/*",
         "--all-scopes-completion",
         "--completion-style=detailed",
         "--header-insertion=never",
@@ -27,5 +28,6 @@
         "--pch-storage=memory",
         "--background-index",
         "--log=verbose"
-    ]
+    ],
+    "C_Cpp.intelliSenseEngine": "disabled"
 }

CMakeLists.txt

@@ -3,10 +3,31 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################
 
+# Save compiler and launcher paths if they are absolute (e.g. from presets or CLI)
+# to prevent conan_toolchain.cmake from overwriting them with relative names.
+set(_ULIB_SAVE_CC  "${CMAKE_C_COMPILER}")
+set(_ULIB_SAVE_CXX "${CMAKE_CXX_COMPILER}")
+set(_ULIB_SAVE_CC_LAUNCHER  "${CMAKE_C_COMPILER_LAUNCHER}")
+set(_ULIB_SAVE_CXX_LAUNCHER "${CMAKE_CXX_COMPILER_LAUNCHER}")
+
 if(EXISTS "${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
     include("${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
 endif()
 
+if(_ULIB_SAVE_CC AND IS_ABSOLUTE "${_ULIB_SAVE_CC}")
+    set(CMAKE_C_COMPILER "${_ULIB_SAVE_CC}" CACHE FILEPATH "C compiler" FORCE)
+endif()
+if(_ULIB_SAVE_CXX AND IS_ABSOLUTE "${_ULIB_SAVE_CXX}")
+    set(CMAKE_CXX_COMPILER "${_ULIB_SAVE_CXX}" CACHE FILEPATH "C++ compiler" FORCE)
+endif()
+if(_ULIB_SAVE_CC_LAUNCHER AND IS_ABSOLUTE "${_ULIB_SAVE_CC_LAUNCHER}")
+    set(CMAKE_C_COMPILER_LAUNCHER "${_ULIB_SAVE_CC_LAUNCHER}" CACHE FILEPATH "C compiler launcher" FORCE)
+endif()
+if(_ULIB_SAVE_CXX_LAUNCHER AND IS_ABSOLUTE "${_ULIB_SAVE_CXX_LAUNCHER}")
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${_ULIB_SAVE_CXX_LAUNCHER}" CACHE FILEPATH "C++ compiler launcher" FORCE)
+endif()
+
+
 cmake_minimum_required (VERSION 3.26)
 
 set(QT_NO_VERSION_CHECK TRUE)

CMakePresets.json

@@ -20,12 +20,12 @@
             "binaryDir": "${sourceDir}/build/${presetName}",
             "cacheVariables": {
                 "CMAKE_BUILD_TYPE": "Release",
-                "CMAKE_C_COMPILER": "clang",
+                "CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
-                "CMAKE_CXX_COMPILER": "clang++",
+                "CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
                 "CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
                 "CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
-                "CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
+                "CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
-                "CMAKE_C_COMPILER_LAUNCHER": "ccache"
+                "CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache"
             }
         },
         {
@@ -36,12 +36,12 @@
             "binaryDir": "${sourceDir}/build/${presetName}",
             "cacheVariables": {
                 "CMAKE_BUILD_TYPE": "Release",
-                "CMAKE_C_COMPILER": "clang",
+                "CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
-                "CMAKE_CXX_COMPILER": "clang++",
+                "CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
                 "CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
                 "CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
-                "CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
+                "CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
-                "CMAKE_C_COMPILER_LAUNCHER": "ccache"
+                "CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache"
             }
         },
         {
@@ -52,12 +52,12 @@
             "binaryDir": "${sourceDir}/build/${presetName}",
             "cacheVariables": {
                 "CMAKE_BUILD_TYPE": "Release",
-                "CMAKE_C_COMPILER": "clang",
+                "CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
-                "CMAKE_CXX_COMPILER": "clang++",
+                "CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
                 "CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
                 "CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
-                "CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
+                "CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
-                "CMAKE_C_COMPILER_LAUNCHER": "ccache",
+                "CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
                 "USE_CUDA": "ON"
             }
         }

app/gcompose/src/ContextModel.cpp

@@ -38,8 +38,8 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
         });
 
         // Connect existing objects
-        for (auto* obj : m_rootContext->GetObjects()) {
+        for (const auto& obj : m_rootContext->GetObjects()) {
-            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+            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()) {
+            for (const auto& obj : ctx->GetObjects()) {
-                findAndRemoveRecursive(obj, target);
+                findAndRemoveRecursive(obj.get(), target);
             }
         }
     };
@@ -244,12 +244,12 @@ bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, in
              // check if targetCtx is descendant of obj
              std::function<bool(uLib::Object*, uLib::Object*)> isDescendant = 
                 [&isDescendant](uLib::Object* root, uLib::Object* target) -> bool {
-                 if (auto ctx = root->GetChildren()) {
+                  if (auto ctx = root->GetChildren()) {
-                     for (auto* child : ctx->GetObjects()) {
+                      for (const auto& child : ctx->GetObjects()) {
-                         if (child == target) return true;
+                          if (child.get() == target) return true;
-                         if (isDescendant(child, target)) return true;
+                          if (isDescendant(child.get(), target)) return true;
-                     }
+                      }
-                 }
+                  }
                  return false;
              };
              if (isDescendant(obj, (uLib::Object*)targetCtx)) invalid = true;

app/gcompose/src/ContextPanel.cpp

@@ -90,6 +90,10 @@ void ContextPanel::setContext(uLib::ObjectsContext* context) {
     m_treeView->expandAll();
 }
 
+void ContextPanel::setPropertyContext(uLib::ObjectsContext* context) {
+    m_propertiesPanel->setContext(context);
+}
+
 void ContextPanel::onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected) {
     uLib::Object* target = nullptr;
     if (!selected.indexes().isEmpty()) {

app/gcompose/src/ContextPanel.h

@@ -20,6 +20,7 @@ public:
     ~ContextPanel();
 
     void setContext(uLib::ObjectsContext* context);
+    void setPropertyContext(uLib::ObjectsContext* context);
     void selectObject(uLib::Object* obj);
     void clearSelection();
 

app/gcompose/src/MainPanel.cpp

@@ -127,7 +127,10 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
 void MainPanel::setContext(uLib::ObjectsContext* context) {
     m_context = context;
     m_contextPanel->setContext(context);
-
+    
+    // Propagate context to all panels for reference property dropdowns
+    m_contextPanel->setPropertyContext(context);
+    m_firstPane->setContext(context);
     if (m_mainVtkContext) {
         if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
             viewport->RemoveProp3D(*m_mainVtkContext);
@@ -179,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()) {
+            for (const auto& obj : context->GetObjects()) {
-                if (auto* p = m_mainVtkContext->GetProp3D(obj)) {
+                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/PropertiesPanel.cpp

@@ -47,4 +47,8 @@ void PropertiesPanel::setObject(uLib::Object* obj) {
     m_editor->setObject(obj);
 }
 
+void PropertiesPanel::setContext(uLib::ObjectsContext* context) {
+    m_editor->setContext(context);
+}
+
 PropertiesPanel::~PropertiesPanel() {}

app/gcompose/src/PropertiesPanel.h

@@ -5,6 +5,7 @@
 
 namespace uLib {
     class Object;
+    class ObjectsContext;
     namespace Qt { class PropertyEditor; }
 }
 
@@ -23,6 +24,9 @@ public:
 
     /** @brief Sets the object to be inspected. */
     void setObject(uLib::Object* obj);
+    
+    /** @brief Sets the context for reference property dropdowns. */
+    void setContext(uLib::ObjectsContext* context);
 
 signals:
     void propertyUpdated();

app/gcompose/src/PropertyWidgets.cpp

@@ -13,6 +13,7 @@
 #include <QSlider>
 #include <QFontDialog>
 #include "Settings.h"
+#include "Core/ObjectsContext.h"
 
 namespace uLib {
 namespace Qt {
@@ -386,7 +387,74 @@ public:
     }
 };
 
-PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr) {
+////////////////////////////////////////////////////////////////////////////////
+// ReferencePropertyWidget
+
+ReferencePropertyWidget::ReferencePropertyWidget(ReferencePropertyBase* prop, ::uLib::ObjectsContext* context, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_RefProp(prop), m_Context(context) {
+    m_Combo = new QComboBox(static_cast<QWidget*>(this));
+    m_Layout->addWidget(m_Combo, 1);
+    refreshCombo();
+    connect(m_Combo, &QComboBox::currentIndexChanged, this, &ReferencePropertyWidget::onComboChanged);
+
+    // Listen for property updates to refresh selected item
+    m_Connection = uLib::Object::connect(prop, &uLib::Object::Updated, [this](){
+        QSignalBlocker blocker(m_Combo);
+        refreshCombo();
+    });
+
+    // Listen for context changes to refresh the dropdown list
+    if (m_Context) {
+        m_ContextConnection = uLib::Object::connect(m_Context, &uLib::Object::Updated, [this](){
+            QSignalBlocker blocker(m_Combo);
+            refreshCombo();
+        });
+    }
+}
+
+ReferencePropertyWidget::~ReferencePropertyWidget() {
+    m_Connection.disconnect();
+    m_ContextConnection.disconnect();
+}
+
+void ReferencePropertyWidget::refreshCombo() {
+    m_Combo->clear();
+    m_Combo->addItem("(none)", QVariant::fromValue((quintptr)0));
+
+    int selectedIdx = 0;
+    Object* currentRef = m_RefProp->GetReferencedObject();
+
+    if (m_Context) {
+        const auto& objects = m_Context->GetObjects();
+        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.get()));
+                if (obj.get() == currentRef) {
+                    selectedIdx = m_Combo->count() - 1;
+                }
+            }
+        }
+    }
+    m_Combo->setCurrentIndex(selectedIdx);
+}
+
+void ReferencePropertyWidget::onComboChanged(int index) {
+    if (index < 0) return;
+    quintptr ptr = m_Combo->itemData(index).value<quintptr>();
+    Object* obj = reinterpret_cast<Object*>(ptr);
+    m_RefProp->SetReferencedObject(obj);
+    Q_EMIT updated();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PropertyEditor
+
+PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr), m_Context(nullptr) {
     m_MainLayout = new QVBoxLayout(this);
     m_MainLayout->setContentsMargins(0, 0, 0, 0);
     m_ScrollArea = new QScrollArea(this);
@@ -488,18 +556,23 @@ void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
                      // widget = new RangePropertyWidget<float>(pflt, m_Container);
                 }
             } else {
-                // Priority 2: Standard factory lookup
+                // Priority 2: Check for reference properties (SmartPointer<T>)
+                if (auto* refProp = dynamic_cast<::uLib::ReferencePropertyBase*>(prop)) {
+                    widget = static_cast<QWidget*>(new ReferencePropertyWidget(refProp, m_Context, m_Container));
+                } else {
+                    // Priority 3: Standard factory lookup
                     auto it = m_Factories.find(prop->GetTypeIndex());
                     if (it != m_Factories.end()) {
                         widget = it->second(prop, m_Container);
                     } else {
-                    // Debug info for unknown types
+                        // Debug info for unknown types
-                    std::cout << "PropertyEditor: No factory for " << prop->GetQualifiedName() 
+                        std::cout << "PropertyEditor: No factory for " << prop->GetQualifiedName() 
-                              << " (Type: " << prop->GetTypeName() << ")" << std::endl;
+                                  << " (Type: " << prop->GetTypeName() << ")" << std::endl;
 
                         widget = new PropertyWidgetBase(prop, m_Container);
-                    widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
+                        widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
                     }
+                }
             }
 
             if (widget) {

app/gcompose/src/PropertyWidgets.h

@@ -4,6 +4,7 @@
 #include <QWidget>
 class QPushButton;
 class QSlider;
+class QComboBox;
 #include <QLabel>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
@@ -21,6 +22,8 @@ class QSlider;
 #include "Math/Dense.h"
 #include "Settings.h"
 
+namespace uLib { class ObjectsContext; }
+
 namespace uLib {
 namespace Qt {
 
@@ -211,12 +214,28 @@ private:
     QPushButton* m_Button;
 };
 
+class ReferencePropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    ReferencePropertyWidget(ReferencePropertyBase* prop, ::uLib::ObjectsContext* context, QWidget* parent = nullptr);
+    virtual ~ReferencePropertyWidget();
+private slots:
+    void onComboChanged(int index);
+private:
+    void refreshCombo();
+    ReferencePropertyBase* m_RefProp;
+    ::uLib::ObjectsContext* m_Context;
+    QComboBox* m_Combo;
+    Connection m_ContextConnection;
+};
+
 class PropertyEditor : public QWidget {
     Q_OBJECT
 public:
     PropertyEditor(QWidget* parent = nullptr);
     virtual ~PropertyEditor();
     void setObject(uLib::Object* obj, bool displayOnly = false);
+    void setContext(uLib::ObjectsContext* context) { m_Context = context; }
     template<typename T>
     void registerFactory(std::function<QWidget*(PropertyBase*, QWidget*)> factory) {
         m_Factories[std::type_index(typeid(T))] = factory;
@@ -228,6 +247,7 @@ signals:
 private:
     void clear();
     uLib::Object* m_Object;
+    uLib::ObjectsContext* m_Context;
     QVBoxLayout* m_MainLayout;
     QScrollArea* m_ScrollArea;
     QWidget* m_Container;

app/gcompose/src/ViewportPane.cpp

@@ -113,6 +113,10 @@ void ViewportPane::setObject(uLib::Object* obj) {
     }
 }
 
+void ViewportPane::setContext(uLib::ObjectsContext* context) {
+    m_displayEditor->setContext(context);
+}
+
 void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
     if (m_viewport) {
         delete m_viewport;

app/gcompose/src/ViewportPane.h

@@ -7,6 +7,7 @@
 
 namespace uLib {
     class Object;
+    class ObjectsContext;
     namespace Qt { class PropertyEditor; }
     namespace Vtk { class Viewport; }
 }
@@ -29,6 +30,9 @@ public:
     
     /** @brief Update the display properties for the given object. */
     void setObject(uLib::Object* obj);
+    
+    /** @brief Sets the context for reference property dropdowns. */
+    void setContext(uLib::ObjectsContext* context);
 
 private slots:
     void onCloseRequested();

docs/object_context.md

@@ -0,0 +1,36 @@
+# Creating Objects and adding to context
+
+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). 
+
+so Adding a Solid or a Logical volume on the scene is not enough. We need to create a PhysicalVolume from the LogicalVolume and add it to the scene to see its instance and apply the TRS to the PhysicalVolume and so to eventually to the representation. 
+
+## Gcompose interaction with objects that have Prop3d and object without 3D actor
+
+In VTK and Qt the objects are organized in a tree structure. When We will add a new object to the scene it will be added to the tree structure and it will be displayed once wrapped in a vtk representation (like vtkContainerBox for instance). 
+
+For objects without 3D representation, they are added to the tree structure but they are not displayed in the scene. But when Object have a internal member that is a reference to another object, this will be represented in the tree structure as a child of the object that contains a reference to it. It is also important to note that the reference can be either the object itself or a smart pointer to the object. So the representation of the child in the tree structure is a placeholder for the object that is referenced and it can be added to many parents, creating multiple instances of the same reference in the tree structure. 
+
+When a object contains a reference to another object, the reference can be set from properties by selecting form the possible instances in the context that are compatible (can be casted) to the type of the reference. 
+In this way the reference appears also as a child in the tree. On the other hand the same add operation can be performed by dragging the object from the tree structure and dropping it on the property of the object that contains the reference. In this case the reference will be set to the parent selecting the compatible menber automatically.

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()) {
+    if (obj) {
-        m_objects.push_back(obj);
+        auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
-        // Connect child's update to context's update to trigger re-renders
+            return sp.get() == obj;
-        Object::connect(obj, &Object::Updated, this, &Object::Updated);
+        });
-        ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+        if (it == m_objects.end()) {
-        this->Updated(); // Signal that the context has been updated
+            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;
+        Object* removedObj = it->get();
-        m_objects.erase(it);
+        // 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/Property.h

@@ -15,6 +15,15 @@
 #include "Core/Archives.h"
 #include "Core/Signal.h"
 #include "Core/Object.h"
+#include "Core/SmartPointer.h"
+
+// Type traits for detecting SmartPointer<T>
+namespace uLib {
+template<typename T> struct is_smart_pointer : std::false_type {};
+template<typename T> struct is_smart_pointer<SmartPointer<T>> : std::true_type {};
+template<typename T> struct smart_pointer_element { using type = void; };
+template<typename T> struct smart_pointer_element<SmartPointer<T>> { using type = T; };
+} // namespace uLib
 
 namespace uLib {
 
@@ -216,6 +225,109 @@ private:
 
 } // namespace uLib
 
+namespace uLib {
+
+/**
+ * @brief Base class for reference properties (SmartPointer<T> fields).
+ * Provides a type-erased interface for getting/setting object references
+ * and checking type compatibility.
+ */
+class ReferencePropertyBase : public PropertyBase {
+public:
+  virtual ~ReferencePropertyBase() {}
+  virtual Object* GetReferencedObject() const = 0;
+  virtual void SetReferencedObject(Object* obj) = 0;
+  virtual bool IsCompatible(Object* obj) const = 0;
+  virtual const char* GetReferenceTypeName() const = 0;
+};
+
+/**
+ * @brief Typed reference property for SmartPointer<T> fields.
+ * Filters context objects by dynamic_cast compatibility with T.
+ */
+template <typename T>
+class ReferenceProperty : public ReferencePropertyBase {
+public:
+  ReferenceProperty(Object* owner, const std::string& name, SmartPointer<T>& ref,
+                    const std::string& units = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_ref(ref), m_ReadOnly(false) {
+      if (m_owner) m_owner->RegisterProperty(this);
+  }
+
+  virtual ~ReferenceProperty() {}
+
+  // PropertyBase interface
+  virtual const std::string& GetName() const override { return m_name; }
+  virtual const char* GetTypeName() const override { return typeid(SmartPointer<T>).name(); }
+  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(ReferencePropertyBase)); }
+  virtual const std::string& GetUnits() const override { return m_units; }
+  virtual void SetUnits(const std::string& units) override { m_units = units; }
+  virtual const std::string& GetGroup() const override { return m_group; }
+  virtual void SetGroup(const std::string& group) override { m_group = group; }
+  virtual bool IsReadOnly() const override { return m_ReadOnly; }
+  void SetReadOnly(bool ro) { m_ReadOnly = ro; }
+
+  virtual std::string GetValueAsString() const override {
+    T* ptr = m_ref.Get();
+    if (!ptr) return "(none)";
+    Object* obj = dynamic_cast<Object*>(ptr);
+    if (obj) {
+      std::string iname = obj->GetInstanceName();
+      if (!iname.empty()) return iname;
+      return obj->GetClassName();
+    }
+    return "(set)";
+  }
+
+  // ReferencePropertyBase interface
+  virtual Object* GetReferencedObject() const override {
+    return dynamic_cast<Object*>(m_ref.Get());
+  }
+
+  virtual void SetReferencedObject(Object* obj) override {
+    if (!obj) {
+      m_ref = SmartPointer<T>(nullptr);
+      this->Updated();
+      if (m_owner) m_owner->Updated();
+      return;
+    }
+    T* casted = dynamic_cast<T*>(obj);
+    if (casted) {
+      m_ref = SmartPointer<T>(casted);
+      this->Updated();
+      if (m_owner) m_owner->Updated();
+    }
+  }
+
+  virtual bool IsCompatible(Object* obj) const override {
+    return dynamic_cast<T*>(obj) != nullptr;
+  }
+
+  virtual const char* GetReferenceTypeName() const override {
+    return typeid(T).name();
+  }
+
+  // Serialization stubs
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::log_archive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override {}
+
+private:
+  Object* m_owner;
+  std::string m_name;
+  std::string m_units;
+  std::string m_group;
+  SmartPointer<T>& m_ref;
+  bool m_ReadOnly;
+};
+
+} // namespace uLib
+
 namespace uLib {
 namespace Archive {
 
@@ -267,7 +379,20 @@ public:
     }
 
     template<class T> void save_property_impl(const char* name, T& val, const char* units, bool hasRange, const T& minVal, const T& maxVal, bool isReadOnly) {
-        if (m_Object) {
+        if (!m_Object) return;
+        if constexpr (is_smart_pointer<T>::value) {
+            // SmartPointer<U> field: create a ReferenceProperty<U> for type-safe selection
+            using ElementT = typename smart_pointer_element<T>::type;
+            auto* p = new ReferenceProperty<ElementT>(m_Object, name, val, units ? units : "", GetCurrentGroup());
+            p->SetReadOnly(isReadOnly);
+            if (m_DisplayOnly) {
+                m_Object->RegisterDisplayProperty(p);
+                Object* obj = m_Object;
+                Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); });
+            } else {
+                m_Object->RegisterDynamicProperty(p);
+            }
+        } else {
             Property<T>* p = new Property<T>(m_Object, name, &val, units ? units : "", GetCurrentGroup());
             set_range_helper(p, hasRange, minVal, maxVal, typename std::is_arithmetic<T>::type());
             p->SetReadOnly(isReadOnly);

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.
+ * @brief Internal control block for shared ownership across polymorphic SmartPointers.
- * 
- * 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.
  */
-template <typename T>
+struct ControlBlock {
-class SmartPointer {
+    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.
+     * @brief Nested reference counter structure. 
-     * Allocates a new T following legacy behavior.
+     * Preserved as a nested template for Boost serialization compatibility.
      */
-    SmartPointer() : m_counter(nullptr) {
+    struct ReferenceCounter {
-        if constexpr (std::is_default_constructible_v<T>) {
+        T* ptr;
-            m_counter = new ReferenceCounter(new T());
+        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); };
+        }
+
+    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) {}
 
-    /**
-     * @brief Constructor from 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);
     }
 
-    /**
+    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){})) { }
-     * @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)) { }
 
-    /**
-     * @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);
     }
 
-    /**
+    template <typename U, typename = std::enable_if_t<std::is_convertible_v<U*, T*>>>
-     * @brief Move constructor.
+    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(); }
-     * @brief Virtual destructor.
-     */
-    virtual ~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);
     }
 
-    /**
+    T& operator*() const noexcept { return *(m_counter->ptr); }
-     * @brief Dereference operator.
-     */
-    T& operator*() const noexcept { return *m_counter->ptr; }
-
-    /**
-     * @brief Member access operator.
-     */
     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) {
+        if (m_counter && m_counter->cb) {
-            m_counter->count.fetch_add(1, std::memory_order_relaxed);
+            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->cb && m_counter->cb->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-                if (m_counter->ptr) {
+                if (m_counter->cb->deleter) m_counter->cb->deleter();
-                    m_counter->deleter(m_counter->ptr);
+                delete m_counter->cb;
-                }
-                delete m_counter;
             }
+            delete m_counter;
             m_counter = nullptr;
         }
     }
 };
 
-/**
+template <typename T, typename U> 
- * @brief Global swap for SmartPointer.
+SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept { 
- */
+    return SmartPointer<T>(r, static_cast<T*>(r.get())); 
-template <typename T>
-void swap(SmartPointer<T>& a, SmartPointer<T>& b) noexcept {
-    a.swap(b);
 }
 
-/**
+template <typename T, typename U> 
- * @brief Equality comparison.
+SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U>& r) noexcept { 
- */
+    if (auto p = dynamic_cast<T*>(r.get())) return SmartPointer<T>(r, p);
-template <typename T, typename U>
+    return SmartPointer<T>(nullptr);
-bool operator==(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
-    return a.get() == b.get();
 }
 
-/**
+template <typename T, typename U> 
- * @brief Inequality comparison.
+SmartPointer<T> const_pointer_cast(const SmartPointer<U>& r) noexcept { 
- */
+    return SmartPointer<T>(r, const_cast<T*>(r.get())); 
-template <typename T, typename U>
-bool operator!=(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
-    return a.get() != b.get();
 }
 
-/**
+template <typename T, typename U> 
- * @brief Comparison with nullptr.
+SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U>& r) noexcept { 
- */
+    return SmartPointer<T>(r, reinterpret_cast<T*>(r.get())); 
-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>
-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;
 }
 
 } // 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);
+    int s = pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
-    assert(CPU_ISSET(0, &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));
+        TEST1(!spt);
-    }
-    {
-        SmartPointer<Test::ObjectMock> spt = new SmartPointer<Test::ObjectMock>;
-        TEST1(test_smpt(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/GeantRegistration.cpp

@@ -12,6 +12,8 @@ ULIB_REGISTER_OBJECT(Material)
 ULIB_REGISTER_OBJECT(Solid)
 ULIB_REGISTER_OBJECT(TessellatedSolid)
 ULIB_REGISTER_OBJECT(BoxSolid)
+ULIB_REGISTER_OBJECT(LogicalVolume)
+ULIB_REGISTER_OBJECT(PhysicalVolume)
 ULIB_REGISTER_OBJECT(Scene)
 ULIB_REGISTER_OBJECT(SkyPlaneEmitterPrimary)
 ULIB_REGISTER_OBJECT(CylinderEmitterPrimary)

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; }
@@ -163,7 +161,7 @@ protected:
 
   G4VPhysicalVolume *m_Physical;
 
-  // ULIB_DECLARE_PROPERTIES(PhysicalVolume)
+  ULIB_DECLARE_PROPERTIES(PhysicalVolume)
 };
 
 
@@ -173,9 +171,11 @@ protected:
 
 
 class TessellatedSolid : public Solid {
-public:
-  uLibTypeMacro(TessellatedSolid, Solid)
 
+  uLibTypeMacro(TessellatedSolid, Solid)
+  ULIB_SERIALIZE_ACCESS
+
+public:
   TessellatedSolid();
   TessellatedSolid(const char *name);
   
@@ -191,6 +191,8 @@ public:
 protected:
   SmartPointer<TriangleMesh> m_Mesh;
   G4TessellatedSolid *m_Solid;
+
+  //ULIB_DECLARE_PROPERTIES(TessellatedSolid)
 };
 
 
@@ -198,12 +200,14 @@ protected:
 //// BOX SOLID /////////////////////////////////////////////////////////////////
 
 class BoxSolid : public Solid {
-public:
+
   uLibTypeMacro(BoxSolid, Solid)
+  ULIB_SERIALIZE_ACCESS
+
+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; }
@@ -222,6 +226,8 @@ private:
   SmartPointer<ContainerBox> m_ContainerBox;
 
   G4Box *m_Solid;
+  
+  ULIB_DECLARE_PROPERTIES(BoxSolid)
 };
 
 

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

src/Vtk/Math/testing/vtkContainerBoxTest.cpp

@@ -35,20 +35,17 @@ using namespace uLib;
 int main() {
   BEGIN_TESTING(vtk ContainerBox Test);
 
-  {
+  ContainerBox* box = new ContainerBox();
-    ContainerBox* box = new ContainerBox();
+  box->SetSize(Vector3f(1_m, 2_m, 1_m));
-    box->Scale(Vector3f(1_m, 2_m, 1_m));
+  box->SetPosition(Vector3f(0, 0, 0));
-    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(dims1);
+  VoxImage<Voxel>* img1 = new VoxImage<Voxel>(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[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);
+  VoxImage<Voxel>* img2 = new VoxImage<Voxel>(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[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));
+  VoxImage<TestVoxel>* img = new VoxImage<TestVoxel>(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,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()) {}
+        m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()),
-  ~ContainerBoxData() {}
+        m_CubeSource(vtkSmartPointer<vtkCubeSource>::New()),
+        m_AxesSource(vtkSmartPointer<vtkAxes>::New()) {}
 };
 
-ContainerBox::ContainerBox(ContainerBox::Content *content)
+ContainerBox::ContainerBox(uLib::ContainerBox *model)
-    : d(new ContainerBoxData()),
+    : Prop3D(), d(new ContainerBoxData()) {
-      ObjectWrapper(content ? content : new Content()) {
+  this->m_model.reset(model);
   this->InstallPipe();
+
   d->m_UpdateSignal = Object::connect(
       this->m_model.get(), &uLib::Object::Updated, this, &ContainerBox::Update);
-      this->Update();
+  this->Update();
 }
 
-ContainerBox::~ContainerBox() { delete d; }
+ContainerBox::~ContainerBox() {
+  uLib::Object::disconnect(this->m_model.get(), &uLib::Object::Updated, this,
+                           &ContainerBox::Update);
+  delete d;
+}
 
 vtkPolyData *ContainerBox::GetPolyData() const {
   // TODO
@@ -80,22 +90,35 @@ void ContainerBox::Update() {
   if (!this->m_model)
     return;
 
-  vtkProp3D *prop = vtkProp3D::SafeDownCast(this->GetProp());
+  // Update the sources with the model's dimensions.
-  if (prop) {
+  // This makes the "natural" bounds of the actors correct for VTK gizmos.
-    // Apply the TRS matrix to the assembly
+  Vector3f size = this->m_model->GetSize();
-    vtkNew<vtkMatrix4x4> m;
+  Vector3f origin = this->m_model->GetOrigin();
-    Matrix4fToVtk(this->m_model->GetMatrix(), m);
-    prop->SetUserMatrix(m);
-    prop->Modified();
-  }
 
-  // Apply the local shape transformation (Size/Origin) to the cube actor
+  // HandlerWidget relies on vtkProp3D::GetBounds() to determine the size
-  vtkNew<vtkMatrix4x4> localM;
+  // and position of its transformation gizmos. Previously, we were applying
-  Matrix4fToVtk(this->m_model->GetLocalMatrix(), localM);
+  // the Size of the container using the actor's UserMatrix. While this looks
-  d->m_Cube->SetUserMatrix(localM);
+  // 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)
+  d->m_CubeSource->SetBounds(origin.x(), origin.x() + size.x(), origin.y(),
-  ConnectionBlock blocker(d->m_UpdateSignal);
+                             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();
+  // Sync the "outer" TRS from the assembly's matrix
-  if (!root)
+  this->Prop3D::SyncFromVtk();
-    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;
 
-  // CUBE
+  vtkSmartPointer<vtkPolyDataMapper> mapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
 
-  vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+  // CUBE //
-  vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
+  mapper->SetInputConnection(d->m_CubeSource->GetOutputPort());
-
-  // 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(axes->GetOutputPort());
+  mapper->SetInputConnection(d->m_AxesSource->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,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)
+  for (const auto& obj : objects)
-    currentObjects[obj] = true;
+    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) {
+  for (const auto& obj : objects) {
-    if (m_Prop3Ds.find(obj) == m_Prop3Ds.end()) {
+    if (m_Prop3Ds.find(obj.get()) == m_Prop3Ds.end()) {
-      Prop3D *prop3d = this->CreateProp3D(obj);
+      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);