not working yet

Geant4's G4EXPATShim creates EXPAT::EXPAT (uppercase) with
IMPORTED_LOCATION set to ${EXPAT_LIBRARY}, which is empty when EXPAT
is found via conda's config-mode package (expat::expat, lowercase).

After find_package(Geant4), patch EXPAT::EXPAT with the real library
path taken from expat::expat IMPORTED_LOCATION_NOCONFIG, falling back
to find_library if needed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.agents/rules/context_exclude_vtk.md

@@ -0,0 +1,9 @@
+---
+trigger: manual
+---
+# Context Restriction: No VTK
+When this rule is active, restrict the operational context to libraries excluding the VTK layer.
+- **Exclude Path**: `src/Vtk`
+- **Include Paths**: `src/Core`, `src/Math`, `src/HEP`, `src/Root`, `src/Python`, `src/utils`
+- **Focus**: Tomographic reconstruction algorithms, data structures in `Core`, and physical modeling in `HEP`. 
+- **Constraint**: Avoid referencing `Prop3D`, `Viewport`, or any VTK-specific headers unless the user overrides this restriction.

.agents/rules/context_gcompose.md

@@ -0,0 +1,9 @@
+---
+trigger: manual
+---
+# Context Focus: gcompose Application
+When this rule is active, prioritize the `gcompose` GUI application.
+- **Primary Path**: `app/gcompose`
+- **Focus**: `MainPanel`, `ContextPanel`, `PropertiesPanel`, and `ViewportPane`.
+- **Integration**: Wiring of Qt signals/slots between the `uLib` core model and the GUI widgets.
+- **Dependency**: Reference `src/Vtk` and `src/Core` as the underlying framework for the application.

.agents/rules/context_vtk.md

@@ -0,0 +1,9 @@
+---
+trigger: always_on
+---
+# Context Inclusion: VTK
+When this rule is active, include the VTK visualization layer in the operational context.
+- **Priority Path**: `src/Vtk`
+- **Focus**: `Prop3D` hierarchy, `Viewport` management, and the synchronization between domain objects and VTK props.
+- **Key Classes**: `vtkViewport`, `vtkQViewport`, `vtkObjectsContext`, and all classes in `src/Vtk/HEP/Geant`.
+- **Logic**: Ensure transformations (TRS) applied to domain objects are correctly mirrored in the visualization layer and vice versa.

.agents/rules/micromamba.md

@@ -1,7 +0,0 @@
----
-trigger: always_on
----
-
-build in build directory using always micromamba "mutom" env.
-build with make flag -j$(nproc).
-

.agents/skills/micromamba_build.md

@@ -0,0 +1,39 @@
+# Skill: Build uLib with Micromamba
+
+This skill provides instructions for building the uLib project using the micromamba environment.
+
+## Context
+- **Environment**: micromamba `uLib`
+- **Output Directory**: `build`
+- **CPU Usage**: All available cores
+
+## Instructions
+
+1. **Environment Setup**:
+   Ensure micromamba is properly initialized and the `uLib` environment is active.
+   ```bash
+   export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
+   export MAMBA_ROOT_PREFIX="/home/share/micromamba"
+   eval "$(/home/share/micromamba/bin/micromamba shell hook --shell bash)"
+   micromamba activate uLib
+   ```
+
+2. **Full Rebuild (if needed)**:
+   If the `build` directory does not exist or a full reconfiguration is required:
+   ```bash
+   conan profile detect --force
+   conan install . --output-folder=build --build=missing
+   cmake --preset conan-release
+   ```
+
+3. **Incremental Build**:
+   Run the build command from the root directory, pointing to the `build` folder and using all cores.
+   ```bash
+   cmake --build build -j$(nproc)
+   ```
+
+4. **Specific Target Build**:
+   To build a specific target (e.g., gcompose):
+   ```bash
+   cmake --build build --target gcompose -j$(nproc)
+   ```

.gitignore

@@ -18,3 +18,5 @@ test_props.xml
 test_props2.xml
 test_boost.cpp
 .claude/settings.json
+build_output.log
+configure_output.log

.vscode/gdb_wrapper.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+export DISPLAY=:1001.0
+/home/share/micromamba/bin/micromamba run -n uLib /usr/bin/gdb "$@"

.vscode/launch.json

@@ -0,0 +1,31 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "gcompose",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/build/app/gcompose/gcompose",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [
+                { "name": "DISPLAY", "value": ":1001.0" }
+            ],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ],
+            "preLaunchTask": "Build gcompose",
+            "miDebuggerPath": "${workspaceFolder}/.vscode/gdb_wrapper.sh"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,17 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build gcompose",
+            "type": "shell",
+            "command": "/home/share/micromamba/bin/micromamba run -n uLib cmake --build build --target gcompose -j$(nproc)",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        }
+    ]
+}

CLAUDE.md

@@ -10,7 +10,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
 export MAMBA_ROOT_PREFIX="/home/share/micromamba"
 eval "$(/home/share/micromamba/bin/micromamba shell hook --shell bash)"
-micromamba activate mutom
+micromamba activate uLib
 
 # Configure (from repo root, using Conan preset — uses Ninja + ccache)
 cmake --preset conan-release
@@ -71,32 +71,32 @@ mutomCore  →  mutomMath  →  mutomDetectors  →  mutomGeant
 - `ObjectsContext` is a container owning a list of `Object*` pointers; signals `ObjectAdded`/`ObjectRemoved`
 
 ### VTK Layer (`src/Vtk/`)
-- `Puppet` (inherits `uLib::Object`): wraps a VTK `vtkProp` for rendering. Has `GetContent()` returning the underlying domain object. Display-only properties are registered via `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro.
+- `Prop3D` (inherits `uLib::Object`): wraps a VTK `vtkProp` for rendering. Has `GetContent()` returning the underlying domain object. Display-only properties are registered via `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro.
-- `Viewport`: base class managing the VTK renderer, picking, selection logic. Maintains `m_Puppets` vector and `m_ObjectToPuppet` map.
+- `Viewport`: base class managing the VTK renderer, picking, selection logic. Maintains `m_Prop3Ds` vector and `m_ObjectToProp3D` map.
-- `QViewport` (inherits `QWidget` + `Viewport`): Qt-embedded VTK widget. Emits Qt signal `puppetSelected(Puppet*)` on click-selection via `OnSelectionChanged`.
+- `QViewport` (inherits `QWidget` + `Viewport`): Qt-embedded VTK widget. Emits Qt signal `prop3dSelected(Prop3D*)` on click-selection via `OnSelectionChanged`.
-- `vtkObjectsContext`: wraps `ObjectsContext`, creating/destroying `Puppet`s as objects come/go. Emits `PuppetAdded`/`PuppetRemoved`.
+- `vtkObjectsContext`: wraps `ObjectsContext`, creating/destroying `Prop3D`s as objects come/go. Emits `Prop3DAdded`/`Prop3DRemoved`.
-- Display properties: `serialize_display()` + `display_properties_archive` registers selected `hrp<T>` fields as `PropertyBase*` in the puppet's `m_DisplayProperties`. `PropertyEditor::setObject(obj, displayOnly=true)` shows only those.
+- Display properties: `serialize_display()` + `display_properties_archive` registers selected `hrp<T>` fields as `PropertyBase*` in the prop3d's `m_DisplayProperties`. `PropertyEditor::setObject(obj, displayOnly=true)` shows only those.
 
 ### gcompose GUI App (`app/gcompose/src/`)
 - `MainPanel`: top-level widget. Owns `ContextPanel` (left) and `ViewportPane` (right). Wires together viewport↔context selection via signals.
 - `ContextPanel`: tree view of `ObjectsContext`. Emits `objectSelected(Object*)`. Contains an embedded `PropertiesPanel`.
 - `PropertiesPanel`: shows `uLib::Object` properties via `PropertyEditor`.
 - `ViewportPane`: embeds `QViewport` + a slide-out "Display Properties" panel (`PropertyEditor` in display-only mode).
-- `PropertyEditor`: populates widgets from `Object::GetProperties()` (all) or `Puppet::GetDisplayProperties()` (display-only mode).
+- `PropertyEditor`: populates widgets from `Object::GetProperties()` (all) or `Prop3D::GetDisplayProperties()` (display-only mode).
 
 ### Selection Sync Flow
 ```
-Viewport click  →  Viewport::SelectPuppet()  →  QViewport::OnSelectionChanged()
+Viewport click  →  Viewport::SelectProp3D()  →  QViewport::OnSelectionChanged()
-                →  emit puppetSelected(p)
+                →  emit prop3dSelected(p)
                 →  MainPanel: contextPanel->selectObject(p->GetContent())  [updates tree + PropertiesPanel]
                 →  MainPanel: firstPane->setObject(p)  [updates Display Properties panel]
 
 ContextPanel tree click  →  emit objectSelected(obj)
-                →  MainPanel: viewport->SelectPuppet(puppet)  [visual selection in VTK]
+                →  MainPanel: viewport->SelectProp3D(prop3d)  [visual selection in VTK]
-                →  MainPanel: firstPane->setObject(puppet)  [updates Display Properties panel]
+                →  MainPanel: firstPane->setObject(prop3d)  [updates Display Properties panel]
 ```
 
 ### Key Patterns
 - **Two signal systems coexist**: Qt signals (`Q_OBJECT`, `connect(...)`) for GUI; `uLib::Object::connect(...)` for domain signals.
-- **Display properties** flow: `Puppet::serialize_display()` → `display_properties_archive` → `RegisterDisplayProperty()` → `PropertyEditor(displayOnly=true)`. Must call `ULIB_ACTIVATE_DISPLAY_PROPERTIES` in the puppet constructor.
+- **Display properties** flow: `Prop3D::serialize_display()` → `display_properties_archive` → `RegisterDisplayProperty()` → `PropertyEditor(displayOnly=true)`. Must call `ULIB_ACTIVATE_DISPLAY_PROPERTIES` in the prop3d constructor.
-- **Puppet ↔ Object map**: `Viewport::m_ObjectToPuppet` allows lookup by domain object; `vtkObjectsContext::GetPuppet(obj)` does the same.
+- **Prop3D ↔ Object map**: `Viewport::m_ObjectToProp3D` allows lookup by domain object; `vtkObjectsContext::GetProp3D(obj)` does the same.

CMakeLists.txt

@@ -15,11 +15,32 @@ if(POLICY CMP0167)
     cmake_policy(SET CMP0167 NEW)
 endif()
 
-
 ## -------------------------------------------------------------------------- ##
 
 project(uLib)
 
+option(ULIB_USE_CCACHE "Use ccache for build acceleration" ON)
+if(ULIB_USE_CCACHE)
+    find_program(CCACHE_PROGRAM ccache)
+    if(CCACHE_PROGRAM)
+        set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+        set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    endif()
+else()
+    set(CMAKE_CXX_COMPILER_LAUNCHER "")
+    set(CMAKE_C_COMPILER_LAUNCHER "")
+endif()
+
+# Applica la flag SOLO se il compilatore è GCC
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_compile_options(-fno-merge-constants)
+endif()
+
+# Disabilita il warning se il compilatore è Clang (o AppleClang)
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_compile_options(-Wno-ignored-optimization-argument)
+endif()
+
 # CUDA Toolkit seems to be missing locally. Toggle ON if nvcc is made available.
 option(USE_CUDA "Enable CUDA support" OFF)
 if(USE_CUDA)
@@ -121,8 +142,13 @@ find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_fra
 include_directories(${Boost_INCLUDE_DIRS})
 
 find_package(Eigen3 CONFIG REQUIRED)
-get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+# if(NOT EIGEN3_INCLUDE_DIRS)
-include_directories(${EIGEN3_INCLUDE_DIRS})
+#     get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+# else()
+#     include_directories(${EIGEN3_INCLUDE_DIRS})
+# endif()
+
+find_package(OpenMP)
 
 find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
@@ -145,6 +171,8 @@ else()
                                 IOXML
                                 IOXMLParser
                                 ImagingCore
+                                ImagingHybrid
+                                ImagingSources
                                 InteractionStyle
                                 InteractionWidgets
                                 RenderingAnnotation

README.md

@@ -30,13 +30,13 @@ You can create and activate the environment using either `micromamba` or `conda`
 **Using Micromamba:**
 ```bash
 micromamba env create -f condaenv.yml
-micromamba activate mutom
+micromamba activate uLib
 ```
 
 **Using Conda:**
 ```bash
 conda env create -f condaenv.yml
-conda activate mutom
+conda activate uLib
 ```
 
 ### Configure and Build
@@ -65,12 +65,24 @@ cmake --preset conan-release
 cmake --build build -j$(nproc)
 ```
 
+5. **Clean build (wipe and rebuild everything):**
+```bash
+cmake --build build --clean-first -j$(nproc)
+```
+
+6. **Run tests:**
+```bash
+cmake --build build --target test -j$(nproc)
+# or equivalently:
+ctest --test-dir build --output-on-failure -j$(nproc)
+```
+
 #### LLVM/Clang build (clang + lld + ccache — fastest)
 
 A `fast` conan profile is provided that uses **clang**, **lld** (LLVM linker), and **ccache**. Install them into your environment first:
 
 ```bash
-micromamba install -n mutom -y clang clangxx lld -c conda-forge
+micromamba install -n uLib -y clang clangxx lld -c conda-forge
 ```
 
 Then build using the `fast` profile:
@@ -91,6 +103,6 @@ The `fast` profile is defined at `~/.conan2/profiles/fast` and sets:
 ### Make python package
 
 ```bash
-micromamba run -n mutom env USE_CUDA=ON poetry install
+micromamba run -n uLib env USE_CUDA=ON poetry install
 ```
 

app/gcompose/CMakeLists.txt

@@ -17,6 +17,8 @@ add_executable(gcompose
     src/PropertyWidgets.cpp
     src/PropertiesPanel.h
     src/PropertiesPanel.cpp
+    src/PreferencesDialog.h
+    src/PreferencesDialog.cpp
 )
 
 set_target_properties(gcompose PROPERTIES

app/gcompose/src/ContextModel.cpp

@@ -148,6 +148,7 @@ QVariant ContextModel::data(const QModelIndex& index, int role) const {
     if (!index.isValid()) return QVariant();
 
     uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+    if (!obj) return QVariant();
     
     if (role == Qt::DisplayRole) {
         QString typeName = getDemangledName(typeid(*obj));

app/gcompose/src/MainPanel.cpp

@@ -13,11 +13,14 @@
 #include <QPushButton>
 #include <QMenu>
 #include <QAction>
+#include <QShortcut>
 #include <QApplication>
 #include <QFileDialog>
 #include <QFileInfo>
 #include "StyleManager.h"
 #include "Math/VoxImage.h"
+#include "PreferencesDialog.h"
+#include "Settings.h"
 
 MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr) {
     this->setObjectName("MainPanel");
@@ -45,17 +48,12 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
     fileMenu->addAction("Open", this, &MainPanel::onOpen);
     fileMenu->addAction("Save", this, &MainPanel::onSave);
     fileMenu->addAction("Save As", this, &MainPanel::onSaveAs);
+    fileMenu->addSeparator();
+    fileMenu->addAction("Preferences", this, &MainPanel::onPreferences);
+    fileMenu->addSeparator();
     fileMenu->addAction("Exit", this, &MainPanel::onExit);
     btnFile->setMenu(fileMenu);
 
-    // Theme Menu Button
-    auto* btnTheme = new QPushButton("Theme", menuPanel);
-    btnTheme->setObjectName("MenuButton");
-    auto* themeMenu = new QMenu(btnTheme);
-    themeMenu->addAction("Dark", this, &MainPanel::onDarkTheme);
-    themeMenu->addAction("Bright", this, &MainPanel::onBrightTheme);
-    btnTheme->setMenu(themeMenu);
-
     // New Menu Button
     auto* btnNew = new QPushButton("Add", menuPanel);
     btnNew->setObjectName("MenuButton");
@@ -73,7 +71,6 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
     menuLayout->addWidget(logo);
     menuLayout->addWidget(btnFile);
     menuLayout->addWidget(btnNew);
-    menuLayout->addWidget(btnTheme);
     menuLayout->addStretch();
 
     mainLayout->addWidget(menuPanel);
@@ -90,13 +87,13 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
     
     connect(m_contextPanel, &ContextPanel::objectSelected, [this](uLib::Object* obj) {
         if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
-            uLib::Vtk::Puppet* puppet = nullptr;
+            uLib::Vtk::Prop3D* prop3d = nullptr;
             if (m_mainVtkContext) {
-                puppet = m_mainVtkContext->GetPuppet(obj);
+                prop3d = m_mainVtkContext->GetProp3D(obj);
             }
-            viewport->SelectPuppet(puppet);
+            viewport->SelectProp3D(prop3d);
-            // Update the display properties in the viewport pane itself - use the puppet proxy if possible
+            // Update the display properties in the viewport pane itself - use the prop3d proxy if possible
-            m_firstPane->setObject(puppet ? (uLib::Object*)puppet : obj);
+            m_firstPane->setObject(prop3d ? (uLib::Object*)prop3d : obj);
         } else {
             m_firstPane->setObject(obj);
         }
@@ -108,6 +105,14 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
     m_rootSplitter->setSizes(sizes);
 
     mainLayout->addWidget(m_rootSplitter, 1);
+    
+    // Shortcuts
+    auto* groupShortcut = new QShortcut(QKeySequence("Ctrl+G"), this);
+    connect(groupShortcut, &QShortcut::activated, [this]() {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            viewport->GroupSelection(m_context);
+        }
+    });
 }
 
 void MainPanel::setContext(uLib::ObjectsContext* context) {
@@ -116,7 +121,7 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
 
     if (m_mainVtkContext) {
         if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
-            viewport->RemovePuppet(*m_mainVtkContext);
+            viewport->RemoveProp3D(*m_mainVtkContext);
         }
         delete m_mainVtkContext;
         m_mainVtkContext = nullptr;
@@ -124,10 +129,10 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
 
     if (context) {
         if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
-            m_mainVtkContext = new uLib::Vtk::vtkObjectsContext(context);
+            m_mainVtkContext = new uLib::Vtk::ObjectsContext(context);
-            // viewport->AddPuppet(*m_mainVtkContext); // redundant
+            // viewport->AddProp3D(*m_mainVtkContext); // redundant
 
-            auto syncSelection = [this](uLib::Vtk::Puppet* p) {
+            auto syncSelection = [this](uLib::Vtk::Prop3D* p) {
                 if (!p) {
                     m_contextPanel->clearSelection();
                     m_firstPane->setObject(nullptr);
@@ -136,14 +141,14 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
                     m_firstPane->setObject(p);
                 }
             };
-            connect(viewport, &uLib::Vtk::QViewport::puppetSelected, syncSelection);
+            connect(viewport, &uLib::Vtk::QViewport::prop3dSelected, syncSelection);
 
-            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetAdded, [this](uLib::Vtk::Puppet* p) {
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::ObjectsContext::Prop3DAdded, [this](uLib::Vtk::Prop3D* p) {
                 if (p) {
                     auto panes = this->findChildren<ViewportPane*>();
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
-                            vp->AddPuppet(*p);
+                            vp->AddProp3D(*p);
                             vp->ZoomAuto();
                             vp->Render();
                         }
@@ -151,25 +156,25 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
                 }
             });
 
-            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetRemoved, [this](uLib::Vtk::Puppet* p) {
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::ObjectsContext::Prop3DRemoved, [this](uLib::Vtk::Prop3D* p) {
                 if (p) {
                     auto panes = this->findChildren<ViewportPane*>();
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
-                            vp->RemovePuppet(*p);
+                            vp->RemoveProp3D(*p);
                             vp->Render();
                         }
                     }
                 }
             });
 
-            // Add any puppets that were created during m_mainVtkContext's construction to all panes
+            // Add any prop3ds that were created during m_mainVtkContext's construction to all panes
             auto panes = this->findChildren<ViewportPane*>();
             for (auto* obj : context->GetObjects()) {
-                if (auto* p = m_mainVtkContext->GetPuppet(obj)) {
+                if (auto* p = m_mainVtkContext->GetProp3D(obj)) {
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
-                            vp->AddPuppet(*p);
+                            vp->AddProp3D(*p);
                         }
                     }
                 }
@@ -236,12 +241,21 @@ void MainPanel::onExit() {
     qApp->quit();
 }
 
-void MainPanel::onDarkTheme() {
+void MainPanel::onPreferences() {
-    StyleManager::applyStyle(qApp, "dark");
+    uLib::Qt::PreferencesDialog dlg(this);
-}
+    if (dlg.exec() == QDialog::Accepted) {
+        // Apply theme
+        auto theme = uLib::Qt::Settings::Instance().GetTheme();
+        StyleManager::applyStyle(qApp, theme == uLib::Qt::Settings::Dark ? "dark" : "bright");
 
-void MainPanel::onBrightTheme() {
+        // Apply rendering preference to all viewports
-    StyleManager::applyStyle(qApp, "bright");
+        bool throttled = uLib::Qt::Settings::Instance().GetThrottledRendering();
+        auto viewports = this->findChildren<uLib::Vtk::QViewport*>();
+        for (auto* vp : viewports) {
+            vp->SetThrottledRendering(throttled);
+            vp->Render();
+        }
+    }
 }
 
 MainPanel::~MainPanel() {}

app/gcompose/src/MainPanel.h

@@ -11,7 +11,7 @@ class PropertiesPanel;
 namespace uLib {
     class ObjectsContext;
     namespace Vtk {
-        class vtkObjectsContext;
+        class ObjectsContext;
     }
 }
 
@@ -30,8 +30,7 @@ private slots:
     void onSaveAs();
     void onExit();
 
-    void onDarkTheme();
+    void onPreferences();
-    void onBrightTheme();
     
     void onCreateObject(const std::string& className);
 
@@ -40,7 +39,7 @@ private:
     ViewportPane* m_firstPane;
     ContextPanel* m_contextPanel;
     uLib::ObjectsContext* m_context;
-    uLib::Vtk::vtkObjectsContext* m_mainVtkContext;
+    uLib::Vtk::ObjectsContext* m_mainVtkContext;
 };
 
 #endif // MAINPANEL_H

app/gcompose/src/PreferencesDialog.cpp

@@ -0,0 +1,99 @@
+#include "PreferencesDialog.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QFormLayout>
+#include <QPushButton>
+#include <QLabel>
+#include <QGroupBox>
+
+namespace uLib {
+namespace Qt {
+
+PreferencesDialog::PreferencesDialog(QWidget* parent) : QDialog(parent) {
+    setWindowTitle("Preferences");
+    setMinimumWidth(400);
+    
+    auto* mainLayout = new QVBoxLayout(this);
+    mainLayout->setSpacing(20);
+    mainLayout->setContentsMargins(20, 20, 20, 20);
+
+    // ── General / Rendering Settings ────────────────────────────────────────
+    auto* renderingGroup = new QGroupBox("Appearance & Performance", this);
+    auto* renderingLayout = new QVBoxLayout(renderingGroup);
+    
+    auto* themeLayout = new QHBoxLayout();
+    themeLayout->addWidget(new QLabel("Color Theme:"));
+    m_themeCombo = new QComboBox(renderingGroup);
+    m_themeCombo->addItem("Dark");
+    m_themeCombo->addItem("Bright");
+    m_themeCombo->setCurrentIndex(Settings::Instance().GetTheme() == Settings::Dark ? 0 : 1);
+    themeLayout->addWidget(m_themeCombo);
+    themeLayout->addStretch();
+    
+    renderingLayout->addLayout(themeLayout);
+    renderingLayout->addSpacing(10);
+
+    m_throttledRendering = new QCheckBox("Enable throttled rendering (recommended for performance)", renderingGroup);
+    m_throttledRendering->setChecked(Settings::Instance().GetThrottledRendering());
+    m_throttledRendering->setToolTip("Limits framerate to ~60fps to reduce CPU/GPU usage.");
+    
+    renderingLayout->addWidget(m_throttledRendering);
+    mainLayout->addWidget(renderingGroup);
+
+    // ── Units Settings ──────────────────────────────────────────────────────
+    auto* unitsGroup = new QGroupBox("Preferred Units", this);
+    auto* unitsLayout = new QFormLayout(unitsGroup);
+    unitsLayout->setLabelAlignment(::Qt::AlignRight);
+    unitsLayout->setSpacing(10);
+
+    auto addUnitRow = [&](const QString& label, Settings::Dimension dim, const QStringList& units) {
+        auto* combo = new QComboBox(unitsGroup);
+        combo->addItems(units);
+        std::string current = Settings::Instance().GetPreferredUnit(dim);
+        int idx = combo->findText(QString::fromStdString(current));
+        if (idx >= 0) combo->setCurrentIndex(idx);
+        
+        unitsLayout->addRow(label + ":", combo);
+        m_unitCombos[dim] = combo;
+    };
+
+    addUnitRow("Length", Settings::Length, {"m", "cm", "mm", "um", "nm"});
+    addUnitRow("Angle", Settings::Angle, {"deg", "rad"});
+    addUnitRow("Energy", Settings::Energy, {"MeV", "GeV", "eV", "keV", "TeV"});
+    addUnitRow("Time", Settings::Time, {"ns", "s", "ms", "us"});
+
+    mainLayout->addWidget(unitsGroup);
+
+    mainLayout->addStretch();
+
+    // ── Buttons ─────────────────────────────────────────────────────────────
+    auto* buttonLayout = new QHBoxLayout();
+    buttonLayout->addStretch();
+    
+    auto* btnCancel = new QPushButton("Cancel", this);
+    connect(btnCancel, &QPushButton::clicked, this, &QDialog::reject);
+    
+    auto* btnOk = new QPushButton("Apply", this);
+    btnOk->setDefault(true);
+    btnOk->setObjectName("DisplayToggleBtn"); // Reusing high-contrast style
+    btnOk->setMinimumWidth(100);
+    connect(btnOk, &QPushButton::clicked, this, &PreferencesDialog::onAccept);
+    
+    buttonLayout->addWidget(btnCancel);
+    buttonLayout->addWidget(btnOk);
+    mainLayout->addLayout(buttonLayout);
+}
+
+void PreferencesDialog::onAccept() {
+    Settings::Instance().SetThrottledRendering(m_throttledRendering->isChecked());
+    Settings::Instance().SetTheme(m_themeCombo->currentIndex() == 0 ? Settings::Dark : Settings::Bright);
+    
+    for (auto const& pair : m_unitCombos) {
+        Settings::Instance().SetPreferredUnit(pair.first, pair.second->currentText().toStdString());
+    }
+    
+    accept();
+}
+
+} // namespace Qt
+} // namespace uLib

app/gcompose/src/PreferencesDialog.h

@@ -0,0 +1,31 @@
+#ifndef GCOMPOSE_PREFERENCESDIALOG_H
+#define GCOMPOSE_PREFERENCESDIALOG_H
+
+#include <QDialog>
+#include <QCheckBox>
+#include <QComboBox>
+#include <map>
+#include <string>
+#include "Settings.h"
+
+namespace uLib {
+namespace Qt {
+
+class PreferencesDialog : public QDialog {
+    Q_OBJECT
+public:
+    explicit PreferencesDialog(QWidget* parent = nullptr);
+
+private slots:
+    void onAccept();
+
+private:
+    QCheckBox* m_throttledRendering;
+    QComboBox* m_themeCombo;
+    std::map<Settings::Dimension, QComboBox*> m_unitCombos;
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif

app/gcompose/src/PropertyWidgets.cpp

@@ -403,10 +403,10 @@ void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
     const std::vector<::uLib::PropertyBase*>* props = &obj->GetProperties();
     
     if (displayOnly) {
-        if (auto* puppet = dynamic_cast<::uLib::Vtk::Puppet*>(obj)) {
+        if (auto* prop3d = dynamic_cast<::uLib::Vtk::Prop3D*>(obj)) {
-            props = &puppet->GetDisplayProperties();
+            props = &prop3d->GetDisplayProperties();
         } else {
-            // If it's not a puppet but displayOnly is requested, showing nothing or fallback?
+            // If it's not a prop3d but displayOnly is requested, showing nothing or fallback?
             // Fallback: core properties.
         }
     }

app/gcompose/src/QViewportPane.cpp

@@ -88,14 +88,14 @@ void QViewportPane::toggleDisplayPanel() {
 
 void QViewportPane::setObject(uLib::Object* obj) {
     m_displayEditor->setObject(obj, true);
-    // Auto-show panel if it's a puppet and we want to highlight this feature?
+    // Auto-show panel if it's a prop3d and we want to highlight this feature?
     // User asked for "hiding panel", so maybe we don't auto-show.
 }
 
 void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
     if (m_viewport) {
-        m_viewport->parentWidget()->layout()->removeWidget(m_viewport);
+        // Use deleteLater() instead of delete to avoid crashes during repaint cycles
-        delete m_viewport;
+        m_viewport->deleteLater();
     }
     m_viewport = viewport;
     m_titleLabel->setText(title);
@@ -105,21 +105,8 @@ void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
     mainAreaLayout->insertWidget(0, m_viewport);
 }
 
-
 QViewportPane::~QViewportPane() {}
 
-void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
-    if (m_viewport) {
-        m_layout->removeWidget(m_viewport);
-        delete m_viewport;
-    }
-    m_viewport = viewport;
-    m_titleLabel->setText(title);
-
-    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-    m_layout->addWidget(m_viewport);
-}
-
 void QViewportPane::addVtkViewport() {
     auto* viewport = new uLib::Vtk::QViewport(this);
     setViewport(viewport, "VTK Viewport");
@@ -179,9 +166,9 @@ void QViewportPane::AttemptSplit(Qt::Orientation orientation) {
     if (currentVtk) {
         auto* newVtk = qobject_cast<uLib::Vtk::QViewport*>(newPane->currentViewport());
         if (newVtk) {
-            // Copy puppets
+            // Copy prop3ds
-            for (auto* puppet : currentVtk->getPuppets()) {
+            for (auto* prop3d : currentVtk->getProp3Ds()) {
-                newVtk->AddPuppet(*puppet);
+                newVtk->AddProp3D(*prop3d);
             }
             // Copy camera
             if (currentVtk->GetRenderer() && newVtk->GetRenderer()) {

app/gcompose/src/Settings.h

@@ -23,6 +23,11 @@ public:
         Dimensionless
     };
 
+    enum Theme {
+        Dark,
+        Bright
+    };
+
     void SetPreferredUnit(Dimension dim, const std::string& unit) {
         m_PreferredUnits[dim] = unit;
     }
@@ -64,9 +69,17 @@ public:
         return Dimensionless;
     }
 
+    bool GetThrottledRendering() const { return m_ThrottledRendering; }
+    void SetThrottledRendering(bool enabled) { m_ThrottledRendering = enabled; }
+
+    Theme GetTheme() const { return m_Theme; }
+    void SetTheme(Theme theme) { m_Theme = theme; }
+
 private:
-    Settings() {}
+    Settings() : m_ThrottledRendering(true), m_Theme(Dark) {}
     std::map<Dimension, std::string> m_PreferredUnits;
+    bool m_ThrottledRendering;
+    Theme m_Theme;
 };
 
 } // namespace Qt

app/gcompose/src/ViewportPane.cpp

@@ -99,15 +99,15 @@ void ViewportPane::toggleDisplayPanel() {
 void ViewportPane::setObject(uLib::Object* obj) {
     m_displayEditor->setObject(obj, true);
     
-    // Check if the object is a Puppet (meaning it has display properties)
+    // Check if the object is a Prop3D (meaning it has display properties)
-    bool isPuppet = (dynamic_cast<::uLib::Vtk::Puppet*>(obj) != nullptr);
+    bool isProp3D = (dynamic_cast<::uLib::Vtk::Prop3D*>(obj) != nullptr);
     
-    // Only show the "Display" toggle button if it's a puppet
+    // Only show the "Display" toggle button if it's a prop3d
-    m_toggleBtn->setVisible(isPuppet);
+    m_toggleBtn->setVisible(isProp3D);
     
-    // If it's a puppet, we might want to keep the panel state if it was already open,
+    // If it's a prop3d, we might want to keep the panel state if it was already open,
-    // or if it's NOT a puppet, definitely hide the toggle and panel.
+    // or if it's NOT a prop3d, definitely hide the toggle and panel.
-    if (!isPuppet) {
+    if (!isProp3D) {
         m_toggleBtn->setChecked(false);
         m_displayPanel->hide();
     }
@@ -115,7 +115,7 @@ void ViewportPane::setObject(uLib::Object* obj) {
 
 void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
     if (m_viewport) {
-        delete m_viewport;
+        m_viewport->deleteLater();
     }
     m_viewport = viewport;
     m_titleLabel->setText(title);

build.log

@@ -1,36 +1 @@
-make: Entering directory '/home/rigoni/devel/cmt/ulib/build'
+ninja: error: loading 'build.ninja': No such file or directory
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxImage.cpp.o
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/TriangleMesh.cpp.o
-[ 30%] Building CXX object src/Core/CMakeFiles/mutomCore.dir/Options.cpp.o
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Dense.cpp.o
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredGrid.cpp.o
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxRaytracer.cpp.o
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredData.cpp.o
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured2DGrid.cpp.o
-[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured4DGrid.cpp.o
-[ 33%] Linking CXX shared library libmutomCore.so
-[ 33%] Built target mutomCore
-[ 36%] Linking CXX shared library libmutomMath.so
-[ 36%] Built target mutomMath
-[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkContainerBox.cpp.o
-[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkInterface.cxx.o
-[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkStructuredGrid.cpp.o
-[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkMuonScatter.cxx.o
-[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkViewer.cpp.o
-[ 63%] Generating mutomRootDict.cxx, libmutomRootDict_rdict.pcm, libmutomRootDict.rootmap
-[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxImage.cpp.o
-[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxRaytracerRepresentation.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorSkinHit.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorHit.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMCTrack.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorInfo.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/RootMuonScatter.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorPrimaryVertex.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMuDetDIGI.cpp.o
-[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/SkinDetectorWriter.cpp.o
-[ 93%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/mutomRootDict.cxx.o
-[ 96%] Linking CXX shared library libmutomVtk.so
-[ 96%] Built target mutomVtk
-[100%] Linking CXX shared library libmutomRoot.so
-[100%] Built target mutomRoot
-make: Leaving directory '/home/rigoni/devel/cmt/ulib/build'

conanfile.txt

@@ -1,6 +1,6 @@
 [requires]
-eigen/3.4.0
+# eigen/5.0.1
-boost/1.83.0
+boost/1.86.0
 # pybind11/3.0.2
 hdf5/1.14.3
 

condaenv.yml

@@ -1,4 +1,4 @@
-name: mutom
+name: uLib
 channels:
   - conda-forge
 dependencies:
@@ -7,4 +7,15 @@ dependencies:
   - cmake
   - conan
   - root
-  - vtk
+  - vtk=9.4 # VTK 9.4
+  - pybind11
+  #- boost=1.86.0 # requested by VTK 9.4
+  - ninja
+  - clang
+  - clangxx
+  - lld
+  - ccache
+  - OpenMP
+  - Geant4
+  - gdb
+  - valgrind

docs/code/vtk/vtk_Prop3D.md

@@ -0,0 +1,48 @@
+# Prop3D
+
+`uLib::Vtk::Prop3D` is a bridge class that wraps VTK 3D representations (`vtkProp`, `vtkProp3D`) and integrates them into the `uLib` object model. It allows the framework to manage visual objects, synchronize them with underlying data models, and expose display-specific properties to the GUI.
+
+## Inheritance
+`uLib::Vtk::Prop3D` : `uLib::Object`
+
+## Key Functionalities
+
+### VTK Integration
+The class provides access to the underlying VTK objects:
+- `GetProp()`: Returns the `vtkProp`.
+- `GetProxyProp()`: Returns the `vtkProp3D`.
+- `GetParts()` / `GetProps()`: Returns `vtkPropCollection` for composite objects.
+
+### Model-View Synchronization
+`Prop3D` ensures that the visual representation stays in sync with the domain model:
+- `Update()`: Synchronizes the VTK representation based on current internal state and properties. Should be called when model data changes.
+- `SyncFromVtk()`: Updates internal state using data from the VTK representation (e.g., after user interaction via gizmos in the 3D view).
+- `GetContent()`: Returns the `uLib::Object` that this `Prop3D` represents visually.
+
+### Visual Appearance
+- **Color & Opacity**: `SetColor(r, g, b)` and `SetOpacity(alpha)`.
+- **Selection**: `SetSelectable(bool)` and `SetSelected(bool)` to manage interactivity and highlighting.
+- **BBox/Scale**: `ShowBoundingBox(bool)` and `ShowScaleMeasures(bool)`.
+
+### Rendering Modes
+The rendering style can be controlled via the `Representation` enum:
+- `Points`
+- `Wireframe`
+- `Surface`
+- `SurfaceWithEdges`
+- `Volume`
+- `Outline`
+- `Slice`
+
+### Display Properties System
+`Prop3D` implements a system to expose specific properties (often marked as `hrp` - human readable properties) to a property editor in the GUI.
+
+- `GetDisplayProperties()`: Returns the list of properties registered for display.
+- `RegisterDisplayProperty(uLib::PropertyBase*)`: Adds a property to the display list.
+- `serialize_display(...)`: A virtual method that subclasses implement to define which properties should be exposed.
+
+#### Activating Display Properties
+To automatically populate the display properties list, the `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro should be called in the constructor. This triggers `serialize_display` using a `display_properties_archive`.
+
+## Implementation Details
+`Prop3D` uses the Pimpl idiom (via `Prop3DData *pd`) to hide VTK-specific implementation details and reduce header dependencies.

docs/update_properties.md

@@ -1,21 +1,21 @@
 
 # Properties and the vtk-gui representation
 
-This is the rationale behind the connection between TRS properties and Puppet Transformation.
+This is the rationale behind the connection between TRS properties and Prop3D Transformation.
 
 The properties from model get propoagated via Object signalling system (the Update signal) to the vtkRepresentation and to the Qt widgets so that the overall transformation of the model reflects into a modification of its representation in vtk and in the gui. 
 
-In addition the properties need to be adjusted also from vtk, for example if user uses handlerwidget to change the transformation this is eventually applied to Puppet and Puppet should propagate the transformation change to the vtk representation object (for instance vtkContainerBox) and the latter eventually propagates the change into the model.
+In addition the properties need to be adjusted also from vtk, for example if user uses handlerwidget to change the transformation this is eventually applied to Prop3D and Prop3D should propagate the transformation change to the vtk representation object (for instance vtkContainerBox) and the latter eventually propagates the change into the model.
 
-the Puppet or the vtk representation wrapper ( vtkContainerBox for instance is the wrapper od ContainerBox ) should not directly show the transformation of the handlerwidget but it should show the transformation of the model once applied so we are always seeing the actual aspect of the model reflected to the vtk representation and not the other way around.
+the Prop3D or the vtk representation wrapper ( vtkContainerBox for instance is the wrapper od ContainerBox ) should not directly show the transformation of the handlerwidget but it should show the transformation of the model once applied so we are always seeing the actual aspect of the model reflected to the vtk representation and not the other way around.
 
 So in syntesis the model is the master and the vtk representation and the gui are the slaves of any modification, but the vtkHandlerWidget is able to apply a transform that should be applied to the model and then the model should propagate the transformation change to the vtk representation and to the gui.
 
-## The Puppet
+## The Prop3D
 
-The puppet is the proxy of the spatial placement of objects in the scene. Puppets should have an internal ContainerBox that is shown in the scene around the content to be able to pick Puppet from vtkViewport using the handler widget. The HandlerWidget moves the Puppet ContainerBox (the red Highlight element whe selected) to reflect the handler current transformation, but the transformation is propagated to the derived Puppet classes like vtkContainerBox. 
+The prop3d is the proxy of the spatial placement of objects in the scene. Prop3Ds should have an internal ContainerBox that is shown in the scene around the content to be able to pick Prop3D from vtkViewport using the handler widget. The HandlerWidget moves the Prop3D ContainerBox (the red Highlight element whe selected) to reflect the handler current transformation, but the transformation is propagated to the derived Prop3D classes like vtkContainerBox. 
 
-The vtkHandlerWidget should handle the transformation of the puppet internal ContainerBox. The changes of the ContainerBox will be propagated to the derived classes and eventually to the model. 
+The vtkHandlerWidget should handle the transformation of the prop3d internal ContainerBox. The changes of the ContainerBox will be propagated to the derived classes and eventually to the model. 
 
 
 

src/Core/Archives.h

@@ -80,6 +80,9 @@ template <class ArchiveImplementation> class polymorphic_iarchive_route;
 namespace boost {
 namespace serialization {
 template <typename T> struct hrp;
+template <typename T> struct hrp_val;
+template <typename T> struct hrp_enum;
+template <typename T> struct hrp_enum_val;
 }
 } // namespace boost
 
@@ -177,6 +180,24 @@ public:
     return *this->This();
   }
 
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp_val<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp_val<T> &>(t));
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp_enum<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp_enum<T> &>(t));
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp_enum_val<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp_enum_val<T> &>(t));
+    return *this->This();
+  }
+
   // the & operator
   template <class T> Archive &operator&(T &t) { return *(this->This()) >> t; }
 
@@ -190,6 +211,21 @@ public:
     return *(this->This()) >> t;
   }
 
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_val<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum_val<T> &t) {
+    return *(this->This()) >> t;
+  }
+
   // the == operator
   template <class T> Archive &operator==(T &t) { return this->operator&(t); }
 
@@ -230,11 +266,61 @@ public:
     return *this->This();
   }
 
+  template <class T> Archive &operator<<(const boost::serialization::hrp<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::hrp_val<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::hrp_enum<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::hrp_enum_val<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::nvp<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+ 
   // the & operator
   template <class T> Archive &operator&(const T &t) {
     return *this->This() << t;
   }
 
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_val<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum_val<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::nvp<T> &t) {
+    return *this->This() << t;
+  }
+
   // the == operator
   template <class T> Archive &operator==(T &t) { return this->operator&(t); }
 

src/Core/CMakeLists.txt

@@ -21,6 +21,7 @@ set(HEADERS
     StringReader.h 
     Threads.h
     Monitor.h
+    Property.h
     Types.h 
     Uuid.h 
     Vector.h

src/Core/DataAllocator.h

@@ -46,6 +46,8 @@ public:
   DataAllocator(size_t size = 0, bool owns_objects = true)
       : m_Size(size), m_RamData(nullptr), m_VramData(nullptr),
         m_Device(MemoryDevice::RAM), m_OwnsObjects(owns_objects) {
+    if (m_Size >= (static_cast<size_t>(1) << 60))
+        throw std::invalid_argument("DataAllocator: absurdly large size requested");
     if (m_Size > 0) {
       if (m_OwnsObjects)
         m_RamData = new T[m_Size]();
@@ -139,7 +141,7 @@ public:
   void MoveToRAM() {
     if (m_Device == MemoryDevice::RAM)
       return;
-    if (!m_RamData && m_Size > 0) {
+    if (!m_RamData && m_Size > 0 && m_Size < (static_cast<size_t>(1) << 60)) {
       if (m_OwnsObjects)
         m_RamData = new T[m_Size]();
       else
@@ -178,7 +180,7 @@ public:
     T *newRam = nullptr;
     T *newVram = nullptr;
 
-    if (size > 0) {
+    if (size > 0 && size < (static_cast<size_t>(1) << 60)) {
       if (m_OwnsObjects)
         newRam = new T[size]();
       else

src/Core/Object.cpp

@@ -60,17 +60,40 @@ public:
     std::string slostr;
   };
 
+  ~ObjectPrivate() {
+    for (auto& s : sigv) delete s.signal;
+  }
+  
   std::string m_InstanceName;
   std::vector<Signal> sigv;
   std::vector<Slot> slov;
   std::vector<PropertyBase*> m_Properties;
   std::vector<PropertyBase*> m_DynamicProperties;
+  std::vector<PropertyBase*> m_DisplayProperties;
   bool m_SignalsBlocked;
 };
 
 // Implementations of Property methods
+void Object::RegisterDisplayProperty(PropertyBase* prop) {
+    if (prop) {
+        for (auto* existing : d->m_DisplayProperties) {
+            if (existing == prop) return;
+            if (existing->GetName() == prop->GetName()) return;
+        }
+        d->m_DisplayProperties.push_back(prop);
+    }
+}
+
+const std::vector<PropertyBase*>& Object::GetDisplayProperties() const {
+    return d->m_DisplayProperties;
+}
+
 void Object::RegisterProperty(PropertyBase* prop) {
     if (prop) {
+        for (auto* existing : d->m_Properties) {
+            if (existing == prop) return;
+            if (existing->GetName() == prop->GetName()) return;
+        }
         d->m_Properties.push_back(prop);
     }
 }
@@ -96,31 +119,19 @@ PropertyBase* Object::GetProperty(const std::string& name) const {
     for (auto* p : d->m_DynamicProperties) {
         if (p->GetName() == name || p->GetQualifiedName() == name) return p;
     }
+    for (auto* p : d->m_DisplayProperties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
     return nullptr;
 }
 
 void Object::NotifyPropertiesUpdated() {
+    // Only notify properties in the primary list to avoid duplicates, 
+    // as all registered properties should be there.
     for (auto* p : d->m_Properties) p->Updated();
-    for (auto* p : d->m_DynamicProperties) p->Updated();
-}
-
-// In Object.h, the template serialize needs to be updated to call property serialization.
-// However, since Object::serialize is a template in the header, we might need a helper here.
-
-template <class ArchiveT>
-void Object::serialize(ArchiveT &ar, const unsigned int version) {
-    ar & boost::serialization::make_nvp("InstanceName", d->m_InstanceName);
-    for (auto* prop : d->m_Properties) {
-        prop->serialize(ar, version);
-    }
 }
 
 void Object::Updated() { ULIB_SIGNAL_EMIT(Object::Updated); }
-void Object::PropertyUpdated() { ULIB_SIGNAL_EMIT(Object::PropertyUpdated); }
-
-template <class ArchiveT>
-void Object::save_override(ArchiveT &ar, const unsigned int version) {}
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -153,6 +164,9 @@ Object::~Object() {
     for (auto* p : d->m_DynamicProperties) {
         delete p;
     }
+    for (auto* p : d->m_DisplayProperties) {
+        delete p;
+    }
     delete d;
 }
 
@@ -194,7 +208,8 @@ void Object::PrintSelf(std::ostream &o) const {
 
 bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
                            const char *name) {
-  ObjectPrivate::Signal s = {fptr, std::string(name), sig};
+  if (!d) return false;
+  ObjectPrivate::Signal s = {fptr, std::string(name ? name : "unnamed"), sig};
   d->sigv.push_back(s);
   return true;
 }

src/Core/Object.h

@@ -78,13 +78,14 @@ public:
   Object(const Object &copy);
   virtual ~Object();
 
-  virtual const char * GetClassName() const { return type_name(); }
+  virtual const char *GetClassName() const { return type_name(); }
-  virtual const char * type_name() const { return "Object"; }
+  virtual const char *type_name() const { return "Object"; }
 
-  const std::string& GetInstanceName() const;
+  const std::string &GetInstanceName() const;
-  void SetInstanceName(const std::string& name);
+  void SetInstanceName(const std::string &name);
 
-  /** @brief Temporarily blocks all signal emissions from this object. Returns previous state. */
+  /** @brief Temporarily blocks all signal emissions from this object. Returns
+   * previous state. */
   bool blockSignals(bool block);
 
   /** @brief Checks if signals are currently blocked. */
@@ -92,12 +93,15 @@ public:
 
   ////////////////////////////////////////////////////////////////////////////
   // PROPERTIES //
-  void RegisterProperty(PropertyBase* prop);
+  virtual void RegisterProperty(PropertyBase *property);
-  void RegisterDynamicProperty(PropertyBase* prop);
+  virtual void RegisterDynamicProperty(PropertyBase *property);
-  const std::vector<PropertyBase*>& GetProperties() const;
+  virtual void RegisterDisplayProperty(PropertyBase *property);
-  PropertyBase* GetProperty(const std::string& name) const;
+  virtual const std::vector<PropertyBase *> &GetProperties() const;
+  virtual const std::vector<PropertyBase *> &GetDisplayProperties() const;
+  PropertyBase *GetProperty(const std::string &name) const;
 
-  /** @brief Sends an Updated signal for all properties of this object. useful for real-time UI refresh. */
+  /** @brief Sends an Updated signal for all properties of this object. useful
+   * for real-time UI refresh. */
   void NotifyPropertiesUpdated();
 
   ////////////////////////////////////////////////////////////////////////////
@@ -107,7 +111,7 @@ public:
   virtual void DeepCopy(const Object &copy);
 
   /** @brief Returns a nested context for children objects, if any. */
-  virtual ObjectsContext* GetChildren() { return nullptr; }
+  virtual ObjectsContext *GetChildren() { return nullptr; }
 
   ////////////////////////////////////////////////////////////////////////////
   // SERIALIZATION //
@@ -115,16 +119,23 @@ public:
   template <class ArchiveT>
   void serialize(ArchiveT &ar, const unsigned int version);
 
-  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::xml_oarchive &ar,
-  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) {}
+                         const unsigned int version) {}
-  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::xml_iarchive &ar,
-  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) {}
+                         const unsigned int version) {}
-  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::text_oarchive &ar,
-  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) {}
+                         const unsigned int version) {}
-  virtual void serialize(Archive::log_archive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::text_iarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::hrt_oarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::hrt_iarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::log_archive &ar, const unsigned int version) {
+  }
 
   template <class ArchiveT>
-  void save_override(ArchiveT &ar, const unsigned int version);
+  void save_override(ArchiveT &ar, const unsigned int version) {}
 
   void SaveConfig(std::ostream &os, int version = 0);
   void LoadConfig(std::istream &is, int version = 0);
@@ -135,9 +146,8 @@ public:
   ////////////////////////////////////////////////////////////////////////////
   // SIGNALS //
 
-  signals:
+signals:
   virtual void Updated();
-  virtual void PropertyUpdated();
 
   // Qt4 style connector //
   static bool connect(const Object *ob1, const char *signal_name,
@@ -158,8 +168,8 @@ public:
   connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
           typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
     SignalBase *sigb = sender->findOrAddSignal(sigf);
-    return ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(sigb, slof,
+    return ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(
-                                                                    receiver);
+        sigb, slof, receiver);
   }
 
   // Lambda/Function object connector //
@@ -181,9 +191,10 @@ public:
   }
 
   template <typename FuncT>
-  static inline Connection connect(SignalBase *sigb, FuncT slof, Object *receiver) {
+  static inline Connection connect(SignalBase *sigb, FuncT slof,
-    return ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(sigb, slof,
+                                   Object *receiver) {
-                                                                    receiver);
+    return ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(
+        sigb, slof, receiver);
   }
 
   template <typename FuncT>

src/Core/ObjectFactory.h

@@ -1,29 +1,31 @@
 #ifndef U_CORE_OBJECTFACTORY_H
 #define U_CORE_OBJECTFACTORY_H
 
-#include <string>
-#include <map>
-#include <vector>
-#include <functional>
 #include "Core/Object.h"
+#include <functional>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <vector>
 
 namespace uLib {
 
 /**
- * @brief Singleton factory for dynamic Object instantiation based on class name.
+ * @brief Singleton factory for dynamic Object instantiation based on class
+ * name.
  */
 class ObjectFactory {
 public:
-    typedef std::function<Object*()> FactoryFunction;
+  typedef std::function<Object *()> FactoryFunction;
 
   /** @brief Get the singleton instance. */
-    static ObjectFactory& Instance();
+  static ObjectFactory &Instance();
 
   /** @brief Register a factory function for a given class name. */
-    void Register(const std::string& className, FactoryFunction func);
+  void Register(const std::string &className, FactoryFunction func);
 
   /** @brief Create a new instance of the specified class. */
-    Object* Create(const std::string& className);
+  Object *Create(const std::string &className);
 
   /** @brief Get the names of all registered classes. */
   std::vector<std::string> GetRegisteredClasses() const;
@@ -33,8 +35,8 @@ private:
   ~ObjectFactory() = default;
 
   // Prevent copy and assignment
-    ObjectFactory(const ObjectFactory&) = delete;
+  ObjectFactory(const ObjectFactory &) = delete;
-    ObjectFactory& operator=(const ObjectFactory&) = delete;
+  ObjectFactory &operator=(const ObjectFactory &) = delete;
 
   std::map<std::string, FactoryFunction> m_factoryMap;
 };
@@ -42,11 +44,11 @@ private:
 /**
  * @brief Helper class to statically register a factory function.
  */
-template <typename T>
+template <typename T> class ObjectRegistrar {
-class ObjectRegistrar {
 public:
-    ObjectRegistrar(const std::string& className) {
+  ObjectRegistrar(const std::string &className) {
-        ObjectFactory::Instance().Register(className, []() -> Object* { return new T(); });
+    ObjectFactory::Instance().Register(className,
+                                       []() -> Object * { return new T(); });
   }
 };
 
@@ -58,10 +60,62 @@ public:
  * Put this in the .cpp file of the class.
  */
 #define ULIB_REGISTER_OBJECT(className)                                        \
-    static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(g_ObjectRegistrar_, __LINE__)(#className);
+  static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(                     \
+      g_ObjectRegistrar_, __LINE__)(#className);
 
 #define ULIB_REGISTER_OBJECT_NAME(className, registeredName)                   \
-    static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(g_ObjectRegistrar_, __LINE__)(registeredName);
+  static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(                     \
+      g_ObjectRegistrar_, __LINE__)(registeredName);
+
+template <typename T> class ObjectWrapper {
+public:
+  ObjectWrapper(const std::string &className) {
+    ObjectFactory::Instance().Register(className,
+                                       []() -> Object * { return new T(); });
+  }
+
+  ObjectWrapper(T *model) : m_model(model) {}
+
+  template <typename U = T,
+            typename = std::enable_if_t<std::is_default_constructible_v<U>>>
+  ObjectWrapper() : m_model(new T()) {}
+
+  ObjectWrapper(const ObjectWrapper &other) : m_model(other.m_model) {}
+
+  ObjectWrapper &operator=(const ObjectWrapper &other) {
+    m_model = other.m_model;
+    return *this;
+  }
+
+  ObjectWrapper(ObjectWrapper &&other) noexcept
+      : m_model(std::move(other.m_model)) {}
+
+  ObjectWrapper &operator=(ObjectWrapper &&other) noexcept {
+    m_model = std::move(other.m_model);
+    return *this;
+  }
+
+  ~ObjectWrapper() = default;
+
+  T *operator->() const { return m_model.get(); }
+
+  T &operator*() const { return *m_model; }
+
+  T *get() const { return m_model.get(); }
+
+  bool operator==(const ObjectWrapper &other) const {
+    return m_model == other.m_model;
+  }
+
+  bool operator!=(const ObjectWrapper &other) const {
+    return m_model != other.m_model;
+  }
+
+  explicit operator bool() const { return m_model != nullptr; }
+
+protected:
+  SmartPointer<T> m_model;
+};
 
 } // namespace uLib
 

src/Core/ObjectsContext.cpp

@@ -8,7 +8,9 @@ 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 || obj == this) return;
+    
+    if (std::find(m_objects.begin(), m_objects.end(), obj) == m_objects.end()) {
         m_objects.push_back(obj);
         // Connect child's update to context's update to trigger re-renders
         Object::connect(obj, &Object::Updated, this, &Object::Updated);

src/Core/Property.h

@@ -5,19 +5,23 @@
 #include <vector>
 #include <sstream>
 #include <typeinfo>
-#include <typeindex> // Added
+#include <typeindex>
 #include <boost/serialization/nvp.hpp>
 #include <boost/lexical_cast.hpp>
-#include <vector>
 #include <boost/type_traits/is_class.hpp>
 #include <boost/mpl/bool.hpp>
-#include <boost/serialization/serialization.hpp>
+#include <set>
+#include <boost/type_traits/is_base_of.hpp>
 #include "Core/Archives.h"
 #include "Core/Signal.h"
 #include "Core/Object.h"
 
 namespace uLib {
 
+namespace Archive {
+class property_register_archive;
+}
+
 /**
  * @brief Base class for properties to allow runtime listing and identification.
  */
@@ -27,7 +31,7 @@ public:
   virtual const std::string& GetName() const = 0;
   virtual const char* GetTypeName() const = 0;
   virtual std::string GetValueAsString() const = 0;
-  virtual std::type_index GetTypeIndex() const = 0; // Added
+  virtual std::type_index GetTypeIndex() const = 0;
   virtual const std::string& GetUnits() const = 0;
   virtual void SetUnits(const std::string& units) = 0;
   virtual const std::vector<std::string>& GetEnumLabels() const {
@@ -49,9 +53,6 @@ public:
       return GetGroup() + "." + GetName();
   }
 
-  // Signal support
-  signals:
-  virtual void Updated() override { ULIB_SIGNAL_EMIT(PropertyBase::Updated); }
 
   // Serialization support for different uLib archives
   virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) override = 0;
@@ -61,42 +62,29 @@ public:
   virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) override = 0;
   virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) override = 0;
   virtual void serialize(Archive::log_archive & ar, const unsigned int version) override = 0;
+  
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) = 0;
 };
 
-
-
-
-
-
-
-
 /**
  * @brief Template class for typed properties.
  */
 template <typename T>
 class Property : public PropertyBase {
 public:
-  // PROXY: Use an existing variable as back-end storage
   Property(Object* owner, const std::string& name, T* valuePtr, const std::string& units = "", const std::string& group = "")
     : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(valuePtr), m_own(false),
       m_HasRange(false), m_HasDefault(false), m_ReadOnly(false) {
-      if (m_owner) {
+      if (m_owner) m_owner->RegisterProperty(this);
-          m_owner->RegisterProperty(this);
-      }
   }
 
-  // MANAGED: Create and own internal storage
   Property(Object* owner, const std::string& name, const T& defaultValue = T(), const std::string& units = "", const std::string& group = "")
     : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(new T(defaultValue)), m_own(true),
       m_HasRange(false), m_HasDefault(true), m_Default(defaultValue), m_ReadOnly(false) {
-      if (m_owner) {
+      if (m_owner) m_owner->RegisterProperty(this);
-          m_owner->RegisterProperty(this);
-      }
   }
 
-  virtual ~Property() {
+  virtual ~Property() { if (m_own) delete m_value; }
-      if (m_own) delete m_value;
-  }
 
   // Identification
   virtual const std::string& GetName() const override { return m_name; }
@@ -107,36 +95,19 @@ public:
   virtual const std::string& GetGroup() const override { return m_group; }
   virtual void SetGroup(const std::string& group) override { m_group = group; }
 
-  
   std::string GetValueAsString() const override {
-      try {
+      try { return boost::lexical_cast<std::string>(*m_value); }
-          return boost::lexical_cast<std::string>(*m_value);
+      catch (...) { std::stringstream ss; ss << *m_value; return ss.str(); }
-      } catch (const boost::bad_lexical_cast&) {
-          std::stringstream ss;
-          ss << *m_value;
-          return ss.str();
-      }
   }
 
   // Accessors
   const T& Get() const { return *m_value; }
-  template<typename U = T>
-  typename std::enable_if<std::is_arithmetic<U>::value, void>::type
-  ValidateT(T& val) {
-    if (m_HasRange) {
-        if (val < m_Min) val = m_Min;
-        if (val > m_Max) val = m_Max;
-    }
-  }
-
-  template<typename U = T>
-  typename std::enable_if<!std::is_arithmetic<U>::value, void>::type
-  ValidateT(T& val) {
-  }
-
   void Set(const T& value) {
+    if (!m_value) return;
     T val = value;
-    ValidateT<T>(val);
+    if constexpr (std::is_arithmetic<T>::value) {
+      if (m_HasRange) { if (val < m_Min) val = m_Min; if (val > m_Max) val = m_Max; }
+    }
     if (*m_value != val) {
       *m_value = val;
       ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
@@ -150,65 +121,54 @@ public:
   void SetReadOnly(bool ro) { m_ReadOnly = ro; }
 
   virtual bool IsReadOnly() const override { return m_ReadOnly; }
-
   virtual bool HasRange() const override { return m_HasRange; }
+  virtual double GetMin() const override { return m_HasRange ? convert_to_double(m_Min) : 0.0; }
+  virtual double GetMax() const override { return m_HasRange ? convert_to_double(m_Max) : 0.0; }
   
-  template<typename U = T>
+  const T& GetMinTyped() const { return m_Min; }
-  typename std::enable_if<std::is_arithmetic<U>::value, double>::type
+  const T& GetMaxTyped() const { return m_Max; }
-  GetMinT() const { return (double)m_Min; }
-
-  template<typename U = T>
-  typename std::enable_if<!std::is_arithmetic<U>::value, double>::type
-  GetMinT() const { return 0.0; }
-
-  template<typename U = T>
-  typename std::enable_if<std::is_arithmetic<U>::value, double>::type
-  GetMaxT() const { return (double)m_Max; }
-
-  template<typename U = T>
-  typename std::enable_if<!std::is_arithmetic<U>::value, double>::type
-  GetMaxT() const { return 0.0; }
-
-  virtual double GetMin() const override { return GetMinT<T>(); }
-  virtual double GetMax() const override { return GetMaxT<T>(); }
 
   virtual bool HasDefault() const override { return m_HasDefault; }
   virtual std::string GetDefaultValueAsString() const override {
-      try { return boost::lexical_cast<std::string>(m_Default); } 
+      try { return boost::lexical_cast<std::string>(m_Default); } catch (...) { return ""; }
-      catch (...) { return ""; }
   }
 
-  // Operators for seamless usage
+  // Operators
   operator const T&() const { return *m_value; }
-  Property& operator=(const T& value) {
+  Property& operator=(const T& value) { Set(value); return *this; }
-    Set(value);
-    return *this;
-  }
 
-  // Signals
   signals:
   virtual void PropertyChanged() { ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged); }
 
+private:
+  template <typename U>
+  static double convert_to_double(const U& val) {
+    return convert_to_double_impl(val, typename std::is_arithmetic<U>::type());
+  }
+  template <typename U>
+  static double convert_to_double_impl(const U& val, std::true_type) { return (double)val; }
+  template <typename U>
+  static double convert_to_double_impl(const U& val, std::false_type) { return 0.0; }
+
+public:
   // Serialization
   template <class ArchiveT>
-  void serialize_impl(ArchiveT & ar, const unsigned int version) {
+  void serialize_helper(ArchiveT & ar, const unsigned int version) {
-    ar & boost::serialization::make_nvp(m_name.c_str(), *m_value);
+    ar & boost::serialization::make_hrp(m_name.c_str(), *m_value, m_units.c_str());
   }
 
-  void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
-  void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
-  void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
-  void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
-  void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
-  void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
-  void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  virtual void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_helper(ar, v); }
   
-  virtual void Updated() override {
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override;
-      PropertyBase::Updated();
-      this->PropertyChanged();
-  }
 
-private:
+
+protected:
   std::string m_name;
   std::string m_units;
   std::string m_group;
@@ -224,20 +184,7 @@ private:
 };
 
 /**
- * @brief Conveninent typedefs for common property types.
+ * @brief Property specialized for enumerations.
- */
-typedef Property<std::string> StringProperty;
-typedef Property<int>           IntProperty;
-typedef Property<unsigned int>  UIntProperty;
-typedef Property<long>          LongProperty;
-typedef Property<unsigned long> ULongProperty;
-typedef Property<float>         FloatProperty;
-typedef Property<double>        DoubleProperty;
-typedef Property<Bool_t>        BoolProperty;
-
-
-/**
- * @brief Property specialized for enumerations, providing labels for GUI representations.
  */
 class EnumProperty : public Property<int> {
 public:
@@ -248,68 +195,49 @@ public:
   const char* GetTypeName() const override { return "Enum"; }
   virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(EnumProperty)); }
 
+  template <class ArchiveT>
+  void serialize_enum_helper(ArchiveT & ar, const unsigned int version) {
+    ar & boost::serialization::make_hrp_enum(m_name.c_str(), *m_value, m_Labels, m_units.c_str());
+  }
+
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override;
+
 private:
   std::vector<std::string> m_Labels;
 };
 
-
-
-
-
-
-
-
-
-
-
-/**
- * @brief Macro to simplify property declaration within a class.
- * Usage: ULIB_PROPERTY(float, Width, 1.0f)
- * It creates a raw member m_Width and a Property proxy Width.
- */
-#define ULIB_PROPERTY(type, name, defaultValue) \
-    type m_##name = defaultValue; \
-    Property<type> name = Property<type>(this, #name, &m_##name);
-
-
 } // namespace uLib
 
 namespace uLib {
 namespace Archive {
-class property_register_archive;
-} // namespace Archive
-} // namespace uLib
 
-namespace boost {
+class property_register_archive
-namespace archive {
+    : public boost::archive::detail::common_oarchive<property_register_archive> {
-namespace detail {
+protected:
-template <>
-class interface_oarchive<uLib::Archive::property_register_archive>
-    : public uLib_interface_oarchive<uLib::Archive::property_register_archive> {};
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-namespace uLib {
-namespace Archive {
-
-/**
- * @brief A special archive that creates and registers Property proxies
- * for any member it encounters wrapped in HRP().
- */
-class property_register_archive : 
-    public boost::archive::detail::common_oarchive<property_register_archive>
-{
     Object* m_Object;
+    bool m_DisplayOnly;
 public:
     friend class boost::archive::detail::interface_oarchive<property_register_archive>;
     friend class boost::archive::save_access;
 
-    typedef boost::archive::detail::common_oarchive<property_register_archive> detail_common_oarchive;
+    using boost::archive::detail::common_oarchive<property_register_archive>::save_override;
 
-    property_register_archive(Object* obj) : 
+    property_register_archive(Object* obj, bool displayOnly = false) : 
         boost::archive::detail::common_oarchive<property_register_archive>(boost::archive::no_header),
-        m_Object(obj) {}
+        m_Object(obj), m_DisplayOnly(displayOnly) {
+        if (obj) m_Visited.insert(dynamic_cast<const void*>(obj));
+    }
+
+    template<class T> property_register_archive &operator&(const T &t) { this->save_override(t); return *this; }
+    template<class T> property_register_archive &operator<<(const T &t) { this->save_override(t); return *this; }
     
     std::string GetCurrentGroup() const {
         std::string group;
@@ -320,77 +248,91 @@ public:
         return group;
     }
 
-    // Core logic: encounter HRP -> Create Dynamic Property
+    template<class T> void register_property(Property<T>& p) {
-    template<class T>
+        save_property_impl(p.GetName().c_str(), const_cast<T&>(p.Get()), p.GetUnits().c_str(), 
-    void save_override(const boost::serialization::hrp<T> &t) {
+                          p.HasRange(), p.GetMinTyped(), p.GetMaxTyped(), p.IsReadOnly());
-        if (m_Object) {
+    }
-            Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp<T>&>(t).value(), t.units() ? t.units() : "", GetCurrentGroup());
+
-            if (t.has_range()) p->SetRange(t.min_val(), t.max_val());
+    void register_enum_property(EnumProperty& p) {
-            if (t.has_default()) p->SetDefault(t.default_val());
+        if (!m_Object) return;
-            p->SetReadOnly(t.is_read_only());
+        EnumProperty* newP = new EnumProperty(m_Object, p.GetName(), const_cast<int*>(&p.Get()), p.GetEnumLabels(), p.GetUnits(), GetCurrentGroup());
-            m_Object->RegisterDynamicProperty(p);
+        newP->SetReadOnly(p.IsReadOnly());
+        if (m_DisplayOnly) {
+            m_Object->RegisterDisplayProperty(newP);
+            Object* obj = m_Object;
+            Object::connect(newP, &Object::Updated, [obj]() { obj->Updated(); });
+        } else {
+            m_Object->RegisterDynamicProperty(newP);
         }
     }
 
-    template<class T>
+    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) {
-    void save_override(const boost::serialization::hrp_val<T> &t) {
         if (m_Object) {
-            // Note: hrp_val stores by value. Property usually points to existing data.
+            Property<T>* p = new Property<T>(m_Object, name, &val, units ? units : "", GetCurrentGroup());
-            // But here we are registering properties from HRP wrappers.
+            set_range_helper(p, hasRange, minVal, maxVal, typename std::is_arithmetic<T>::type());
-            // If it's hrp_val, it means it's an rvalue from a getter. 
+            p->SetReadOnly(isReadOnly);
-            // The hrp_val wrapper itself owns the value.
+            if (m_DisplayOnly) {
-            // However, the property_register_archive is temporary.
+                m_Object->RegisterDisplayProperty(p);
-            // This is a bit tricky. Usually HRP(rvalue) is meant for read-only display.
+                Object* obj = m_Object;
-            // Let's use the address of the value in the wrapper, but mark it read-only.
+                Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); });
-            Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp_val<T>&>(t).value(), t.units() ? t.units() : "", GetCurrentGroup());
+            } else {
-            if (t.has_range()) p->SetRange(t.min_val(), t.max_val());
-            if (t.has_default()) p->SetDefault(t.default_val());
-            p->SetReadOnly(t.is_read_only());
                 m_Object->RegisterDynamicProperty(p);
             }
         }
+    }
 
-    template<class T>
+    template<class U> static void set_range_helper(Property<U>* p, bool hasRange, const U& minVal, const U& maxVal, std::true_type) { if (hasRange) p->SetRange(minVal, maxVal); }
-    void save_override(const boost::serialization::hrp_enum<T> &t) {
+    template<class U> static void set_range_helper(Property<U>* p, bool hasRange, const U& minVal, const U& maxVal, std::false_type) {}
+
+    template<class T> void save_override(const boost::serialization::hrp<T> &t) {
+        // To handle T correctly without deduction issues, we assume T can be passed to save_property_impl
+        T dummy = T(); // Ensure we can construct T
+        save_property_impl(t.name(), const_cast<boost::serialization::hrp<T>&>(t).value(), t.units(), t.has_range(), t.has_range() ? t.min_val() : dummy, t.has_range() ? t.max_val() : dummy, t.is_read_only());
+    }
+    template<class T> void save_override(const boost::serialization::hrp_val<T> &t) {
+        T dummy = T();
+        save_property_impl(t.name(), const_cast<boost::serialization::hrp_val<T>&>(t).value(), t.units(), t.has_range(), t.has_range() ? t.min_val() : dummy, t.has_range() ? t.max_val() : dummy, t.is_read_only());
+    }
+    template<class T> void save_override(const boost::serialization::hrp_enum<T> &t) {
         if (m_Object) {
             EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
             p->SetReadOnly(t.is_read_only());
-            m_Object->RegisterDynamicProperty(p);
+            if (m_DisplayOnly) { m_Object->RegisterDisplayProperty(p); Object* obj = m_Object; Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); }); }
+            else { m_Object->RegisterDynamicProperty(p); }
         }
     }
-
+    template<class T> void save_override(const boost::serialization::hrp_enum_val<T> &t) {
-    template<class T>
-    void save_override(const boost::serialization::hrp_enum_val<T> &t) {
         if (m_Object) {
             EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum_val<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
             p->SetReadOnly(t.is_read_only());
-            m_Object->RegisterDynamicProperty(p);
+            if (m_DisplayOnly) { m_Object->RegisterDisplayProperty(p); Object* obj = m_Object; Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); }); }
+            else { m_Object->RegisterDynamicProperty(p); }
         }
     }
 
-    // Handle standard NVPs by recursing (important for base classes)
+    template<class T> void save_override(const boost::serialization::nvp<T> &t) {
-    template<class T>
-    void save_override(const boost::serialization::nvp<T> &t) {
         if (t.name()) m_GroupStack.push_back(t.name());
         this->save_helper(t.const_value(), typename boost::is_class<T>::type());
         if (t.name()) m_GroupStack.pop_back();
     }
 
-    // Recursion for nested classes, ignore primitives
+    void save_override(const std::string &t) {}
-    template<class T>
+    template<class T> void save_override(T * const & t) {
-    void save_override(const T &t) {
+        if (!t) return;
-        this->save_helper(t, typename boost::is_class<T>::type());
+        this->save_pointer_helper(t, typename boost::is_base_of<Object, T>::type());
     }
-
+    template<class T> void save_pointer_helper(T* t, boost::mpl::true_) {
-    template<class T>
+        const void* ptr = dynamic_cast<const void*>(t);
-    void save_helper(const T &t, boost::mpl::true_) {
+        if (m_Visited.find(ptr) != m_Visited.end()) return;
-        boost::serialization::serialize_adl(*this, const_cast<T&>(t), 0);
+        m_Visited.insert(ptr);
+        this->save_override(*t);
     }
+    template<class T> void save_pointer_helper(T* t, boost::mpl::false_) {}
+    template<class T> void save_override(const T &t) { this->save_helper(t, typename boost::is_class<T>::type()); }
+    template<class T> void save_helper(const T &t, boost::mpl::true_) { boost::serialization::serialize_adl(*this, const_cast<T&>(t), 0); }
+    void save_helper(const std::string &t, boost::mpl::true_) {}
+    template<class T> void save_helper(const T &t, boost::mpl::false_) {}
 
-    template<class T>
-    void save_helper(const T &t, boost::mpl::false_) {}
-
-    // Required attribute overrides for common_oarchive
     void save_override(const boost::archive::object_id_type & t) {}
     void save_override(const boost::archive::object_reference_type & t) {}
     void save_override(const boost::archive::version_type & t) {}
@@ -400,30 +342,30 @@ public:
     void save_override(const boost::archive::class_name_type & t) {}
     void save_override(const boost::archive::tracking_type & t) {}
 
-private:
+protected:
     std::vector<std::string> m_GroupStack;
+    std::set<const void*> m_Visited;
 };
 
+} // namespace Archive
+} // namespace uLib
 
+namespace uLib {
+
+template <typename T>
+inline void Property<T>::serialize(Archive::property_register_archive & ar, const unsigned int v) {
+  ar.register_property(*this);
+}
+
+inline void EnumProperty::serialize(Archive::property_register_archive & ar, const unsigned int v) {
+  ar.register_enum_property(*this);
+}
+
+namespace Archive {
 
-/**
- * @brief Convenience macro to automatically activate and register all HRP members
- * as uLib properties. Usage: ULIB_ACTIVATE_PROPERTIES(obj)
- */
 #define ULIB_ACTIVATE_PROPERTIES(obj) \
     { uLib::Archive::property_register_archive _ar_tmp(&(obj)); _ar_tmp & (obj); }
 
-/**
- * @brief Declares a private member that automatically calls ULIB_ACTIVATE_PROPERTIES
- * in every constructor of the class. Place this macro as the last declaration
- * inside the class body (before the closing brace).
- *
- * Usage: ULIB_DECLARE_PROPERTIES(ClassName)
- *
- * This replaces per-constructor ULIB_ACTIVATE_PROPERTIES(*this) calls.
- * RegisterDynamicProperty deduplicates by qualified name, so re-registration
- * from inherited activators in a hierarchy is safe.
- */
 #define ULIB_DECLARE_PROPERTIES(SelfType) \
 private: \
     struct _PropActivator { \
@@ -434,6 +376,31 @@ private: \
     } _prop_activator{this};
 
 } // namespace Archive
+
+// Convenience macro: declares a named Property<T> member with a default value.
+// Usage inside a class body (requires 'this' to be available, so use in-class initializer):
+//   ULIB_PROPERTY(int, MyProp, 42)
+#define ULIB_PROPERTY(type, name, defaultVal) \
+    ::uLib::Property<type> name{this, #name, (type)(defaultVal)};
+
+// Common property type aliases
+typedef Property<bool>        BoolProperty;
+typedef Property<int>         IntProperty;
+typedef Property<float>       FloatProperty;
+typedef Property<double>      DoubleProperty;
+typedef Property<std::string> StringProperty;
+
+template <class ArchiveT>
+void serialize_properties_helper(ArchiveT &ar, const std::vector<PropertyBase*> &props, unsigned int version) {
+    for (auto* prop : props) prop->serialize(ar, version);
+}
+
+template <class ArchiveT>
+void Object::serialize(ArchiveT &ar, const unsigned int version) {
+    ar & boost::serialization::make_nvp("InstanceName", this->GetInstanceName());
+    serialize_properties_helper(ar, this->GetProperties(), version);
+}
+
 } // namespace uLib
 
 #endif // U_CORE_PROPERTY_H

src/Core/SmartPointer.h

@@ -23,89 +23,249 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_SMARTPOINTER_H
 #define U_CORE_SMARTPOINTER_H
 
+#include <atomic>
+#include <functional>
+#include <type_traits>
+#include <utility>
 
 namespace uLib {
 
+/**
+ * @brief A smart pointer implementation inspired by std::shared_ptr.
+ * 
+ * Features modernized C++11/14/17 syntax, thread-safe reference counting,
+ * move semantics, and support for custom deleters.
+ * 
+ * NOTE: Default constructor allocates a new T following legacy behavior.
+ */
 template <typename T>
 class SmartPointer {
-    typedef T element_type;
 public:
+    using element_type = T;
 
-    explicit
+    /**
-    SmartPointer(T* ptr = NULL) : m_counter(0) {
+     * @brief Constructor from raw pointer.
-        if(!ptr) ptr = new T;
+     * If ptr is nullptr, a new T is allocated (legacy behavior).
+     */
+    explicit SmartPointer(T* ptr = nullptr) : m_counter(nullptr) {
+        if (!ptr) {
+            if constexpr (std::is_default_constructible_v<T>) {
+                ptr = new T(); 
+            }
+        }
         if (ptr) m_counter = new ReferenceCounter(ptr);
     }
 
-    // TakeReference //
+    /**
-    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref,0)) { }
+     * @brief Constructor with custom deleter.
-
+     */
-    SmartPointer(const SmartPointer& copy) throw () {
+    template <typename D>
-        acquire(copy.m_counter);
+    SmartPointer(T* ptr, D deleter) : m_counter(nullptr) {
+        if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
     }
 
-    SmartPointer(SmartPointer * copy) throw () {
+    /**
-        acquire(copy->m_counter);
+     * @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);
+    }
+
+    /**
+     * @brief Move constructor.
+     */
+    SmartPointer(SmartPointer&& other) noexcept : m_counter(other.m_counter) {
+        other.m_counter = nullptr;
+    }
+
+    /**
+     * @brief Virtual destructor.
+     */
     virtual ~SmartPointer() { release(); }
 
-    SmartPointer & operator=(const SmartPointer& copy) {
+    /**
-        if (this != &copy)
+     * @brief Copy assignment.
-        {
+     */
+    SmartPointer& operator=(const SmartPointer& other) noexcept {
+        if (this != &other) {
             release();
-            acquire(copy.m_counter);
+            acquire(other.m_counter);
         }
         return *this;
     }
 
-    T & operator*() const throw () {  return *m_counter->ptr; }
+    /**
-    T * operator->() const throw () {  return m_counter->ptr; }
+     * @brief Move assignment.
+     */
+    SmartPointer& operator=(SmartPointer&& other) noexcept {
+        if (this != &other) {
+            release();
+            m_counter = other.m_counter;
+            other.m_counter = nullptr;
+        }
+        return *this;
+    }
 
-    T * get() const throw () {
+    /**
-        return m_counter ? m_counter->ptr : 0; }
+     * @brief Resets the smart pointer to hold a new raw pointer.
-    bool unique() const throw () {
+     */
-        return (m_counter ? m_counter->count == 1 : true);  }
+    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);
+    }
 
-  private:
+    /**
+     * @brief Swaps contents with another SmartPointer.
+     */
+    void swap(SmartPointer& other) noexcept {
+        std::swap(m_counter, other.m_counter);
+    }
 
-    struct ReferenceCounter
+    /**
-    {
+     * @brief Dereference operator.
-      ReferenceCounter(T* ptr = 0, unsigned c = 1) : ptr(ptr), count(c) { }
+     */
+    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; }
+
+    /**
+     * @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;
+    }
+
+    /**
+     * @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; }
+
+private:
+    struct ReferenceCounter {
         T* ptr;
-      unsigned count;
+        std::atomic<uint32_t> count;
-    } * m_counter;
+        std::function<void(T*)> deleter;
 
-    // increment the count
+        ReferenceCounter(T* p, uint32_t initial_count = 1)
-    void acquire(ReferenceCounter* c) throw ()
+            : 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* m_counter;
+
+    void acquire(ReferenceCounter* c) noexcept {
         m_counter = c;
-        if (c && c->count>0) ++c->count;
+        if (c) {
+            c->count.fetch_add(1, std::memory_order_relaxed);
+        }
     }
 
-    // decrement the count, delete if it is 0
+    void release() noexcept {
-    void release() {
         if (m_counter) {
-            if (--m_counter->count == 0) {
+            if (m_counter->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-                delete m_counter->ptr;
+                if (m_counter->ptr) {
+                    m_counter->deleter(m_counter->ptr);
                 }
-            if (m_counter->count <= 0) {
                 delete m_counter;
-                m_counter = NULL;
+            }
+            m_counter = nullptr;
         }
     }
-    }
-
 };
 
-
+/**
-
+ * @brief Global swap for SmartPointer.
+ */
+template <typename T>
+void swap(SmartPointer<T>& a, SmartPointer<T>& b) noexcept {
+    a.swap(b);
 }
 
-#endif // SMARTPOINTER_H
+/**
+ * @brief Equality comparison.
+ */
+template <typename T, typename U>
+bool operator==(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
+    return a.get() == b.get();
+}
+
+/**
+ * @brief Inequality comparison.
+ */
+template <typename T, typename U>
+bool operator!=(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
+    return a.get() != b.get();
+}
+
+/**
+ * @brief Comparison with nullptr.
+ */
+template <typename T>
+bool operator==(const SmartPointer<T>& a, std::nullptr_t) noexcept {
+    return a.get() == nullptr;
+}
+
+template <typename T>
+bool operator==(std::nullptr_t, const SmartPointer<T>& a) noexcept {
+    return a.get() == nullptr;
+}
+
+template <typename T>
+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
+
+#endif // U_CORE_SMARTPOINTER_H

src/Core/Types.h

@@ -139,7 +139,6 @@ typedef id_t Id_t;
 typedef void *Pointer_t;
 typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
 
-
 //--- bit manipulation ---------------------------------------------------------
 #ifndef BIT
 #define BIT(n) (1ULL << (n))

src/Core/testing/CMakeLists.txt

@@ -2,6 +2,8 @@
 # TESTS
 set( TESTS
         SmartVectorTest
+        SmartPointerTest
+        ObjectWrapperTest
         VectorTest
         ObjectFlagsTest
         ObjectParametersTest

src/Core/testing/ObjectWrapperTest.cpp

@@ -0,0 +1,28 @@
+#include "Core/ObjectFactory.h"
+#include <iostream>
+
+struct NonDefault {
+    NonDefault(int) {}
+};
+
+struct Default {
+    Default() : value(42) {}
+    int value;
+};
+
+int main() {
+    std::cout << "Testing ObjectWrapper with Default Constructible type..." << std::endl;
+    uLib::ObjectWrapper<Default> w1;
+    
+    std::cout << "Testing ObjectWrapper with Non-Default Constructible type..." << std::endl;
+    NonDefault nd(10);
+    uLib::ObjectWrapper<NonDefault> w2(&nd);
+    
+    // The following would NOT compile without SFINAE:
+    // uLib::ObjectWrapper<NonDefault> w3; 
+
+    std::cout << "Tests passed (compilation and manual instantiation)!" << std::endl;
+    return 0;
+}
+
+

src/Core/testing/VectorTest.cpp

@@ -38,7 +38,7 @@ inline const unsigned long VectorSplice(const _Tp &_it, const _Tp &_end,
 
   _Tp it = _it;
   _Tp end = _end - 1;
-  for (it; it != end;) {
+  for (; it != end;) {
     if (_comp(*it, value))
       it++;
     else if (_comp(*end, value)) {

src/HEP/Geant/EmitterPrimary.cpp

@@ -39,7 +39,7 @@ EmitterPrimary::EmitterPrimary()
   // Initial position and direction through AffineTransform
   // 10m on Z axis, pointing towards origin
   this->SetPosition(Vector3f(0, 0, 10000.0));
-  // Default orientation is identity (pointing along -Z if we rotate the puppet accordingly)
+  // Default orientation is identity (pointing along -Z if we rotate the prop3d accordingly)
   // But fParticleGun defaults are set here and overridden in GeneratePrimaries
 }
 

src/HEP/Geant/EmitterPrimary.hh

@@ -32,7 +32,7 @@ class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransf
     virtual ~EmitterPrimary();
 
     // Metodo principale chiamato all'inizio di ogni evento
-    virtual void GeneratePrimaries(G4Event*);         
+    virtual void GeneratePrimaries(G4Event*) override;
 
     virtual void Updated() override { ULIB_SIGNAL_EMIT(EmitterPrimary::Updated); }
     
@@ -51,7 +51,7 @@ class SkyPlaneEmitterPrimary : public EmitterPrimary
     SkyPlaneEmitterPrimary();
     virtual ~SkyPlaneEmitterPrimary();
 
-    virtual void GeneratePrimaries(G4Event*);
+    virtual void GeneratePrimaries(G4Event*) override;
 
     void SetPlane(const uLib::Vector3f& p0, const uLib::Vector3f& normal);
     void SetSkySize(const uLib::Vector2f& size);
@@ -72,7 +72,7 @@ class CylinderEmitterPrimary : public EmitterPrimary
     CylinderEmitterPrimary();
     virtual ~CylinderEmitterPrimary();
 
-    virtual void GeneratePrimaries(G4Event*);
+    virtual void GeneratePrimaries(G4Event*) override;
 
     void SetRadius(float r);
     float GetRadius() const { return m_Radius; }
@@ -101,7 +101,7 @@ class QuadMeshEmitterPrimary : public EmitterPrimary
     virtual ~QuadMeshEmitterPrimary();
 
     // Metodo principale chiamato all'inizio di ogni evento
-    virtual void GeneratePrimaries(G4Event*);
+    virtual void GeneratePrimaries(G4Event*) override;
 
     void SetMesh(uLib::QuadMesh* mesh);
     

src/HEP/Geant/Solid.cpp

@@ -105,6 +105,8 @@ void Solid::SetTransform(Matrix4f transform) {
         m_Physical->SetTranslation(*m_Position);
         m_Physical->SetRotation(m_Rotation);
     }
+
+    std::cout << "Solid " << GetName() << " position: " << pos << " rotation: " << m << std::endl;
 }
 
 void Solid::SetParent(Solid *parent) {

src/Math/Assembly.cpp

@@ -37,27 +37,18 @@ Assembly::Assembly(const Assembly &copy)
       m_GroupSelection(copy.m_GroupSelection) {}
 
 Assembly::~Assembly() {
-    for (auto const& [obj, conn] : m_ChildConnections) {
-        conn.disconnect();
-    }
-    m_ChildConnections.clear();
 }
 
 void Assembly::AddObject(Object *obj) {
+    if (!obj || obj == this) return;
+
     if (auto *at = dynamic_cast<AffineTransform *>(obj)) {
         at->SetParent(this);
     }
+    
+    // Base class already handles the list and child->parent update connection
     ObjectsContext::AddObject(obj);
     
-    // Connect to child updates to recompute AABB
-    m_ChildConnections[obj] = Object::connect(obj, &Object::Updated, [this](){
-        this->ComputeBoundingBox();
-        this->Updated(); // Signal that assembly itself changed (AABB-wise)
-    });
-
-    // Parent -> Child propagation for world matrix updates
-    Object::connect(this, &Object::Updated, obj, &Object::Updated);
-
     this->ComputeBoundingBox();
 }
 
@@ -67,12 +58,6 @@ void Assembly::RemoveObject(Object *obj) {
             at->SetParent(nullptr);
     }
     
-    auto itConn = m_ChildConnections.find(obj);
-    if (itConn != m_ChildConnections.end()) {
-        itConn->second.disconnect();
-        m_ChildConnections.erase(itConn);
-    }
-    
     ObjectsContext::RemoveObject(obj);
     this->ComputeBoundingBox();
 }

src/Math/Assembly.h

@@ -31,6 +31,7 @@
 #include "Math/Transform.h"
 
 namespace uLib {
+namespace Vtk { class Assembly; }
 
 /**
  * @brief Assembly groups geometric objects (ContainerBox, Cylinder, etc.)
@@ -41,11 +42,12 @@ namespace uLib {
  * transformation that is applied on top of each child's own transform.
  *
  * A bounding box is automatically computed from all contained objects and
- * can be queried or shown/hidden through the VTK puppet.
+ * can be queried or shown/hidden through the VTK prop3d.
  */
 class Assembly : public ObjectsContext, public TRS {
 public:
     uLibTypeMacro(Assembly, ObjectsContext, TRS)
+    friend class Vtk::Assembly;
     
 
     Assembly();
@@ -81,7 +83,7 @@ public:
 
     /**
      * @brief Controls whether the bounding box wireframe should be shown
-     * in the viewer (used by the VTK puppet).
+     * in the viewer (used by the VTK prop3d).
      */
     void SetShowBoundingBox(bool show);
     bool GetShowBoundingBox() const;
@@ -112,7 +114,6 @@ private:
     bool     m_ShowBoundingBox;
     bool     m_GroupSelection;
     bool     m_InUpdated = false;
-    std::map<Object*, Connection> m_ChildConnections;
 
     ULIB_DECLARE_PROPERTIES(Assembly)
 };

src/Math/Dense.h

@@ -50,9 +50,9 @@
 // #include <Eigen/src/Core/Matrix.h>
 #include <stdlib.h>
 
-#include <Eigen/Dense>
-#include "Core/Types.h"
 #include "Core/Property.h"
+#include "Core/Types.h"
+#include <Eigen/Dense>
 
 //// BOOST SERIALIZATION ///////////////////////////////////////////////////////
 
@@ -150,7 +150,6 @@ typedef Eigen::MatrixXi MatrixXi;
 typedef Eigen::MatrixXf MatrixXf;
 typedef Eigen::MatrixXd MatrixXd;
 
-
 ////////////////////////////////////////////////////////////////////////////////
 // Vector String interaction ///////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -192,7 +191,7 @@ std::string VectorxT_ToString(const Eigen::Matrix<T, size, 1> &vec) {
 // }
 
 template <typename T, int size>
-void operator >> (std::string &str, Eigen::Matrix<T, size, 1> &vec) {
+void operator>>(std::string &str, Eigen::Matrix<T, size, 1> &vec) {
   VectorxT_StringTo(vec, str);
 }
 
@@ -205,9 +204,7 @@ public:
   typedef Eigen::Matrix<Scalarf, 4, 1> BaseClass;
 
   _HPoint3f() : BaseClass(0, 0, 0, p) {}
-  _HPoint3f(int rows, int cols) : BaseClass() {
+  _HPoint3f(int rows, int cols) : BaseClass() { this->operator()(3) = p; }
-    this->operator()(3) = p;
-  }
   _HPoint3f(float x, float y, float z) : BaseClass(x, y, z, p) {}
   _HPoint3f(Vector3f &in) : BaseClass(in.homogeneous()) {
     this->operator()(3) = p;
@@ -250,13 +247,13 @@ struct _HError3f {
   HVector3f position_error;
   HVector3f direction_error;
 };
-  typedef struct _HError3f HError3f;
+typedef struct _HError3f HError3f;
 
- inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
+inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
   stream << "HError3f(" << "ept[" << err.position_error.transpose()
          << "] , edr[" << err.direction_error.transpose() << "]) ";
   return stream;
- }
+}
 
 typedef Property<Scalari> ScalariProperty;
 typedef Property<Scalarui> ScalaruiProperty;
@@ -296,7 +293,7 @@ typedef Property<Matrix4d> Matrix4dProperty;
 typedef Property<HVector3f> HVector3fProperty;
 typedef Property<HPoint3f> HPoint3fProperty;
 
- } // namespace uLib
+} // namespace uLib
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

src/Math/MathRegistrations.cpp

@@ -1,12 +1,12 @@
 #include "Core/ObjectFactory.h"
+#include "Math/Assembly.h"
 #include "Math/ContainerBox.h"
 #include "Math/Cylinder.h"
 #include "Math/Geometry.h"
-#include "Math/TriangleMesh.h"
 #include "Math/QuadMesh.h"
-#include "Math/VoxImage.h"
-#include "Math/Assembly.h"
 #include "Math/StructuredData.h"
+#include "Math/TriangleMesh.h"
+#include "Math/VoxImage.h"
 
 namespace uLib {
 
@@ -14,8 +14,6 @@ ULIB_REGISTER_OBJECT(TRS)
 ULIB_REGISTER_OBJECT(ContainerBox)
 ULIB_REGISTER_OBJECT(Cylinder)
 ULIB_REGISTER_OBJECT(Assembly)
-ULIB_REGISTER_OBJECT(CylindricalGeometry)
-ULIB_REGISTER_OBJECT(SphericalGeometry)
 ULIB_REGISTER_OBJECT(TriangleMesh)
 ULIB_REGISTER_OBJECT(QuadMesh)
 ULIB_REGISTER_OBJECT_NAME(VoxImage<Voxel>, "VoxImage")

src/Math/Transform.h

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 /*
  * Copyright (C) 2012  Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>
  *
@@ -45,84 +43,66 @@
  *
  */
 
-
 #ifndef U_TRANSFORM_H
 #define U_TRANSFORM_H
 
-#include <Eigen/Geometry>
-#include "Math/Units.h"
 #include "Math/Dense.h"
-
+#include "Math/Units.h"
+#include <Eigen/Geometry>
 
 namespace uLib {
 
-
-
-using Eigen::Isometry3f;
 using Eigen::Isometry3d;
+using Eigen::Isometry3f;
 
-using Eigen::Affine3f;
 using Eigen::Affine3d;
+using Eigen::Affine3f;
 
-using Eigen::Projective3f;
 using Eigen::Projective3d;
-
+using Eigen::Projective3f;
-
-
-
-
-
 
 ////////////////////////////////////////////////////////////////////////////////
 /////////  AFFINE TRANSFORM  WRAPPER  //////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
 class AffineTransform : virtual public Object {
 public:
-    uLibTypeMacro(AffineTransform, Object)
+uLibTypeMacro(AffineTransform, Object) protected :
-protected:
 
     Affine3f m_T;
   AffineTransform *m_Parent;
 
 public:
-    AffineTransform() :
+  AffineTransform() : m_T(Matrix4f::Identity()), m_Parent(NULL) {}
-        m_T(Matrix4f::Identity()),
-        m_Parent(NULL)
-    {}
 
-    AffineTransform(AffineTransform *parent) :
+  AffineTransform(AffineTransform *parent)
-        m_T(Matrix4f::Identity()),
+      : m_T(Matrix4f::Identity()), m_Parent(parent) {}
-        m_Parent(parent)
-    {}
 
-    AffineTransform(const AffineTransform &copy) :
+  AffineTransform(const AffineTransform &copy)
-        m_T(copy.m_T),
+      : m_T(copy.m_T), m_Parent(copy.m_Parent) {}
-        m_Parent(copy.m_Parent)
-    {}
 
-    Affine3f& GetTransform() { return m_T; }
+  Affine3f &GetTransform() { return m_T; }
 
   AffineTransform *GetParent() const { return this->m_Parent; }
 
   void SetParent(AffineTransform *name) { this->m_Parent = name; }
 
-    void SetMatrix (const Matrix4f &mat) { m_T.matrix() = mat; }
+  void SetMatrix(const Matrix4f &mat) { m_T.matrix() = mat; }
-    Matrix4f& GetMatrix () { return m_T.matrix(); }
+  Matrix4f &GetMatrix() { return m_T.matrix(); }
-    const Matrix4f& GetMatrix () const { return m_T.matrix(); }
+  const Matrix4f &GetMatrix() const { return m_T.matrix(); }
 
-    Matrix4f GetWorldMatrix() const
+  Matrix4f GetWorldMatrix() const {
-    {
+    if (!m_Parent)
-        if(!m_Parent) return m_T.matrix();
+      return m_T.matrix();
-        else return  m_Parent->GetWorldMatrix() * m_T.matrix(); // T = B * A //
+    else
+      return m_Parent->GetWorldMatrix() * m_T.matrix(); // T = B * A //
   }
 
-    void SetWorldMatrix(const Matrix4f &mat)
+  void SetWorldMatrix(const Matrix4f &mat) {
-    {
+    if (!m_Parent)
-        if(!m_Parent) m_T.matrix() = mat;
+      m_T.matrix() = mat;
-        else m_T.matrix() = m_Parent->GetWorldMatrix().inverse() * mat;
+    else
+      m_T.matrix() = m_Parent->GetWorldMatrix().inverse() * mat;
   }
 
   void SetPosition(const Vector3f &v) { this->m_T.translation() = v; }
@@ -143,44 +123,40 @@ public:
                     this->m_T.linear().col(2).norm());
   }
 
-
   void Rotate(const Matrix3f &m) { this->m_T.rotate(m); }
 
-    void Rotate(const float angle, Vector3f axis)
+  void Rotate(const float angle, Vector3f axis) {
-    {
     axis.normalize(); // prehaps not necessary ( see eigens )
-        Eigen::AngleAxisf ax(angle,axis);
+    Eigen::AngleAxisf ax(angle, axis);
     this->m_T.rotate(Eigen::Quaternion<float>(ax));
   }
 
   void Rotate(const Vector3f euler_axis) {
     float angle = euler_axis.norm();
-        Rotate(angle,euler_axis);
+    Rotate(angle, euler_axis);
   }
 
   void PreRotate(const Matrix3f &m) { this->m_T.prerotate(m); }
 
-    void QuaternionRotate(const Vector4f &q)
+  void QuaternionRotate(const Vector4f &q) {
-    { this->m_T.rotate(Eigen::Quaternion<float>(q)); }
+    this->m_T.rotate(Eigen::Quaternion<float>(q));
+  }
 
   void EulerYZYRotate(const Vector3f &e) {
     Matrix3f mat;
-        mat =     Eigen::AngleAxisf(e.x(), Vector3f::UnitY())
+    mat = Eigen::AngleAxisf(e.x(), Vector3f::UnitY()) *
-                * Eigen::AngleAxisf(e.y(), Vector3f::UnitZ())
+          Eigen::AngleAxisf(e.y(), Vector3f::UnitZ()) *
-                * Eigen::AngleAxisf(e.z(), Vector3f::UnitY());
+          Eigen::AngleAxisf(e.z(), Vector3f::UnitY());
     m_T.rotate(mat);
   }
 
-    void FlipAxes(int first, int second)
+  void FlipAxes(int first, int second) {
-    {
     Matrix3f mat = Matrix3f::Identity();
     mat.col(first).swap(mat.col(second));
     m_T.rotate(mat);
   }
 };
 
-
-
 ////////////////////////////////////////////////////////////////////////////////
 /////////  TRS PARAMETERS  /////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -189,11 +165,10 @@ typedef Eigen::Affine3f AffineMatrix;
 
 class TRS : public AffineTransform {
 
-    uLibTypeMacro(TRS, AffineTransform)
+uLibTypeMacro(TRS, AffineTransform) ULIB_SERIALIZE_ACCESS
-    ULIB_SERIALIZE_ACCESS
     // ULIB_DECLARE_PROPERTIES(TRS)
 
-public:
+    public :
 
     Vector3f position = Vector3f::Zero();
   Vector3f rotation = Vector3f::Zero();
@@ -201,28 +176,27 @@ public:
 
   TRS() = default;
 
-    TRS(const class AffineTransform& at) {
+  TRS(const class AffineTransform &at) { this->FromMatrix(at.GetMatrix()); }
-        this->FromMatrix(at.GetMatrix());
-    }
 
-    TRS(const Matrix4f& mat) {
+  TRS(const Matrix4f &mat) { this->FromMatrix(mat); }
-        this->FromMatrix(mat);
-    }
 
-    void FromMatrix(const Matrix4f& mat) {
+  void FromMatrix(const Matrix4f &mat) {
-        this->position = mat.block<3,1>(0,3);
+    this->position = mat.block<3, 1>(0, 3);
 
-        Matrix3f linear = mat.block<3,3>(0,0);
+    Matrix3f linear = mat.block<3, 3>(0, 0);
     this->scaling(0) = linear.col(0).norm();
     this->scaling(1) = linear.col(1).norm();
     this->scaling(2) = linear.col(2).norm();
 
     Matrix3f rot = linear;
-        if (this->scaling(0) > 1e-6) rot.col(0) /= this->scaling(0);
+    if (this->scaling(0) > 1e-6)
-        if (this->scaling(1) > 1e-6) rot.col(1) /= this->scaling(1);
+      rot.col(0) /= this->scaling(0);
-        if (this->scaling(2) > 1e-6) rot.col(2) /= this->scaling(2);
+    if (this->scaling(1) > 1e-6)
+      rot.col(1) /= this->scaling(1);
+    if (this->scaling(2) > 1e-6)
+      rot.col(2) /= this->scaling(2);
 
-        Vector3f euler = rot.eulerAngles(2, 1, 0); 
+    Vector3f euler = rot.canonicalEulerAngles(2, 1, 0);
     this->rotation = Vector3f(euler(2), euler(1), euler(0));
 
     this->SetMatrix(mat);
@@ -246,9 +220,7 @@ public:
     this->SyncMatrix();
   }
 
-    void SyncMatrix() {
+  void SyncMatrix() { this->GetTransform() = GetAffineMatrix(); }
-        this->GetTransform() = GetAffineMatrix();
-    }
 
   void Updated() override {
     this->SyncMatrix();
@@ -257,13 +229,12 @@ public:
   }
 
   template <class ArchiveT>
-    void serialize(ArchiveT & ar, const unsigned int version) {
+  void serialize(ArchiveT &ar, const unsigned int version) {
-        ar & HRPU(position, "mm");
+    ar &HRPU(position, "mm");
-        ar & HRPU(rotation, "rad"); 
+    ar &HRPU(rotation, "rad");
-        ar & HRP(scaling);
+    ar &HRP(scaling);
   }
 
-
   AffineMatrix GetAffineMatrix() const {
     AffineMatrix m = AffineMatrix::Identity();
     m.translate(position);
@@ -274,31 +245,19 @@ public:
     return m;
   }
 
-    Matrix4f GetMatrix() const {
+  Matrix4f GetMatrix() const { return this->GetAffineMatrix().matrix(); }
-        return this->GetAffineMatrix().matrix();
-    }
-
-
-    
-    
 };
 
-
+inline std::ostream &operator<<(std::ostream &os, const TRS &trs) {
-
-
-
-inline std::ostream& operator<<(std::ostream& os, const TRS& trs) {
   os << trs.position << " " << trs.rotation << " " << trs.scaling;
   return os;
 }
 
-inline std::istream& operator>>(std::istream& is, TRS& trs) {
+inline std::istream &operator>>(std::istream &is, TRS &trs) {
   is >> trs.position >> trs.rotation >> trs.scaling;
   return is;
 }
 
-} // uLib
+} // namespace uLib
 
-
+#endif // U_TRANSFORM_H
-
-#endif//U_TRANSFORM_H

src/Math/Units.h

@@ -13,41 +13,41 @@ namespace uLib {
   using namespace CLHEP;
 
   inline namespace literals {
-    constexpr double operator"" _m(long double v) { return static_cast<double>(v) * CLHEP::meter; }
+    constexpr double operator""_m(long double v) { return static_cast<double>(v) * CLHEP::meter; }
-    constexpr double operator"" _cm(long double v) { return static_cast<double>(v) * CLHEP::centimeter; }
+    constexpr double operator""_cm(long double v) { return static_cast<double>(v) * CLHEP::centimeter; }
-    constexpr double operator"" _mm(long double v) { return static_cast<double>(v) * CLHEP::millimeter; }
+    constexpr double operator""_mm(long double v) { return static_cast<double>(v) * CLHEP::millimeter; }
-    constexpr double operator"" _um(long double v) { return static_cast<double>(v) * CLHEP::micrometer; }
+    constexpr double operator""_um(long double v) { return static_cast<double>(v) * CLHEP::micrometer; }
-    constexpr double operator"" _nm(long double v) { return static_cast<double>(v) * CLHEP::nanometer; }
+    constexpr double operator""_nm(long double v) { return static_cast<double>(v) * CLHEP::nanometer; }
-    constexpr double operator"" _km(long double v) { return static_cast<double>(v) * CLHEP::kilometer; }
+    constexpr double operator""_km(long double v) { return static_cast<double>(v) * CLHEP::kilometer; }
 
-    constexpr double operator"" _m(unsigned long long v) { return static_cast<double>(v) * CLHEP::meter; }
+    constexpr double operator""_m(unsigned long long v) { return static_cast<double>(v) * CLHEP::meter; }
-    constexpr double operator"" _cm(unsigned long long v) { return static_cast<double>(v) * CLHEP::centimeter; }
+    constexpr double operator""_cm(unsigned long long v) { return static_cast<double>(v) * CLHEP::centimeter; }
-    constexpr double operator"" _mm(unsigned long long v) { return static_cast<double>(v) * CLHEP::millimeter; }
+    constexpr double operator""_mm(unsigned long long v) { return static_cast<double>(v) * CLHEP::millimeter; }
-    constexpr double operator"" _um(unsigned long long v) { return static_cast<double>(v) * CLHEP::micrometer; }
+    constexpr double operator""_um(unsigned long long v) { return static_cast<double>(v) * CLHEP::micrometer; }
-    constexpr double operator"" _nm(unsigned long long v) { return static_cast<double>(v) * CLHEP::nanometer; }
+    constexpr double operator""_nm(unsigned long long v) { return static_cast<double>(v) * CLHEP::nanometer; }
-    constexpr double operator"" _km(unsigned long long v) { return static_cast<double>(v) * CLHEP::kilometer; }
+    constexpr double operator""_km(unsigned long long v) { return static_cast<double>(v) * CLHEP::kilometer; }
 
-    constexpr double operator"" _deg(long double v) { return static_cast<double>(v) * CLHEP::degree; }
+    constexpr double operator""_deg(long double v) { return static_cast<double>(v) * CLHEP::degree; }
-    constexpr double operator"" _rad(long double v) { return static_cast<double>(v) * CLHEP::radian; }
+    constexpr double operator""_rad(long double v) { return static_cast<double>(v) * CLHEP::radian; }
-    constexpr double operator"" _deg(unsigned long long v) { return static_cast<double>(v) * CLHEP::degree; }
+    constexpr double operator""_deg(unsigned long long v) { return static_cast<double>(v) * CLHEP::degree; }
-    constexpr double operator"" _rad(unsigned long long v) { return static_cast<double>(v) * CLHEP::radian; }
+    constexpr double operator""_rad(unsigned long long v) { return static_cast<double>(v) * CLHEP::radian; }
 
-    constexpr double operator"" _ns(long double v) { return static_cast<double>(v) * CLHEP::nanosecond; }
+    constexpr double operator""_ns(long double v) { return static_cast<double>(v) * CLHEP::nanosecond; }
-    constexpr double operator"" _s(long double v) { return static_cast<double>(v) * CLHEP::second; }
+    constexpr double operator""_s(long double v) { return static_cast<double>(v) * CLHEP::second; }
-    constexpr double operator"" _ms(long double v) { return static_cast<double>(v) * CLHEP::millisecond; }
+    constexpr double operator""_ms(long double v) { return static_cast<double>(v) * CLHEP::millisecond; }
-    constexpr double operator"" _ns(unsigned long long v) { return static_cast<double>(v) * CLHEP::nanosecond; }
+    constexpr double operator""_ns(unsigned long long v) { return static_cast<double>(v) * CLHEP::nanosecond; }
-    constexpr double operator"" _s(unsigned long long v) { return static_cast<double>(v) * CLHEP::second; }
+    constexpr double operator""_s(unsigned long long v) { return static_cast<double>(v) * CLHEP::second; }
-    constexpr double operator"" _ms(unsigned long long v) { return static_cast<double>(v) * CLHEP::millisecond; }
+    constexpr double operator""_ms(unsigned long long v) { return static_cast<double>(v) * CLHEP::millisecond; }
 
-    constexpr double operator"" _MeV(long double v) { return static_cast<double>(v) * CLHEP::megaelectronvolt; }
+    constexpr double operator""_MeV(long double v) { return static_cast<double>(v) * CLHEP::megaelectronvolt; }
-    constexpr double operator"" _eV(long double v) { return static_cast<double>(v) * CLHEP::electronvolt; }
+    constexpr double operator""_eV(long double v) { return static_cast<double>(v) * CLHEP::electronvolt; }
-    constexpr double operator"" _keV(long double v) { return static_cast<double>(v) * CLHEP::kiloelectronvolt; }
+    constexpr double operator""_keV(long double v) { return static_cast<double>(v) * CLHEP::kiloelectronvolt; }
-    constexpr double operator"" _GeV(long double v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
+    constexpr double operator""_GeV(long double v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
-    constexpr double operator"" _TeV(long double v) { return static_cast<double>(v) * CLHEP::teraelectronvolt; }
+    constexpr double operator""_TeV(long double v) { return static_cast<double>(v) * CLHEP::teraelectronvolt; }
-    constexpr double operator"" _MeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::megaelectronvolt; }
+    constexpr double operator""_MeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::megaelectronvolt; }
-    constexpr double operator"" _eV(unsigned long long v) { return static_cast<double>(v) * CLHEP::electronvolt; }
+    constexpr double operator""_eV(unsigned long long v) { return static_cast<double>(v) * CLHEP::electronvolt; }
-    constexpr double operator"" _keV(unsigned long long v) { return static_cast<double>(v) * CLHEP::kiloelectronvolt; }
+    constexpr double operator""_keV(unsigned long long v) { return static_cast<double>(v) * CLHEP::kiloelectronvolt; }
-    constexpr double operator"" _GeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
+    constexpr double operator""_GeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
   }
 }
 

src/Root/CMakeLists.txt

@@ -33,7 +33,11 @@ set(DICTIONARY_HEADERS muCastorMCTrack.h
                        SkinDetectorWriter.h)
 
 set(LIBRARIES ${ROOT_LIBRARIES}
-              ${PACKAGE_LIBPREFIX}Math)
+              ${PACKAGE_LIBPREFIX}Math
+              Eigen3::Eigen)
+
+get_target_property(EIGEN3_INC Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+include_directories(${EIGEN3_INC})
 
 set(rDictName ${PACKAGE_LIBPREFIX}RootDict)
 root_generate_dictionary(${rDictName} ${DICTIONARY_HEADERS}

src/Root/muCastorMCTrack.h

@@ -1,41 +1,38 @@
 #ifndef muCastor_MCTRACK_H
 #define muCastor_MCTRACK_H
 
-//########################################
+// ########################################
 //  muCastorMCTrack class
 //  Created at the University of Brescia, Italy
 //  Date: December 2011
 //  Autors: Germano Bonomi   germano.bonomi@ing.unibs.it
 //          Martin Subieta   martin.subieta@ing.unibs.it
-//########################################
+// ########################################
 
-#include <iostream>
+#include "Detectors/MuonScatter.h"
-#include "vector"
 #include "TObject.h"
 #include "TParticle.h"
-#include "Detectors/MuonScatter.h"
+#include "vector"
+#include <iostream>
 
 class TClonesArray;
 
-class muCastorMCTrack : public TObject
+class muCastorMCTrack : public TObject {
-{
-
- public:
 
+public:
   /**  Default constructor  **/
   muCastorMCTrack();
 
   /**  Constructor from TParticle  **/
-  muCastorMCTrack(TParticle* particle);
+  muCastorMCTrack(TParticle *particle);
 
   /**  Destructor  **/
   virtual ~muCastorMCTrack();
   void Reset();
 
-
   /**  Accessors  **/
-   Int_t          GetFirstDaughter()  const { return fDaughter[0];}
+  Int_t GetFirstDaughter() const { return fDaughter[0]; }
-   Int_t          GetMother()  const { return fMother[0];}
+  Int_t GetMother() const { return fMother[0]; }
 
   /**  Modifiers  **/
   virtual void AddPoint(TLorentzVector pos, TLorentzVector mom);
@@ -52,8 +49,7 @@ class muCastorMCTrack : public TObject
   }
 
 public:
-
+  /* Private variables - copying private variables of TParticle */
-/* Private variables - copying private variables of TParticle */
 
   Int_t fPdgCode;     // PDG code of the particle
   Int_t fMother[2];   // Indices of the mother particles
@@ -80,9 +76,9 @@ public:
   Double_t *fPntMomZ; //[fNpoints] array of points (pz) belonging to this track
   Double_t *fPntE;    //[fNpoints] array of points (E) belonging to this track
 
-  ClassDef(muCastorMCTrack,1);
+  ClassDef(muCastorMCTrack, 1);
-
 };
 
-uLib::MuonScatter &operator << (uLib::MuonScatter &mu, const muCastorMCTrack &bsmu);
+uLib::MuonScatter &operator<<(uLib::MuonScatter &mu,
-#endif //muCastor_MCTRACK_H   
+                              const muCastorMCTrack &bsmu);
+#endif // muCastor_MCTRACK_H

src/Vtk/CMakeLists.txt

@@ -4,6 +4,7 @@ set(HEADERS uLibVtkInterface.h
             vtkQViewport.h
             vtkViewport.h
             vtkObjectsContext.h
+            vtkMultiSelectionProp.h
             )
 
 set(SOURCES uLibVtkInterface.cxx
@@ -12,6 +13,7 @@ set(SOURCES uLibVtkInterface.cxx
             vtkQViewport.cpp
             vtkViewport.cpp
             vtkObjectsContext.cpp
+            vtkMultiSelectionProp.cpp
             )
 
 ## Pull in Math VTK wrappers (sets MATH_SOURCES / MATH_HEADERS)
@@ -37,6 +39,8 @@ list(APPEND HEADERS ${HEP_GEANT_HEADERS})
 set(LIBRARIES Eigen3::Eigen
               ${ROOT_LIBRARIES}
               ${VTK_LIBRARIES}
+              VTK::ImagingHybrid
+              VTK::ImagingSources
               ${PACKAGE_LIBPREFIX}Math
               ${PACKAGE_LIBPREFIX}Detectors
               ${PACKAGE_LIBPREFIX}Geant)
@@ -56,7 +60,7 @@ set_target_properties(${libname} PROPERTIES
                        AUTOMOC ON
                        AUTOUIC ON
                        AUTORCC ON)
-target_link_libraries(${libname} ${LIBRARIES} Qt6::Widgets)
+target_link_libraries(${libname} PUBLIC ${LIBRARIES} Qt6::Widgets)
 
 install(TARGETS ${libname}
         EXPORT "uLibTargets"

src/Vtk/HEP/Detectors/testing/vtkDetectorChamberTest.cpp

@@ -24,7 +24,7 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
-#include "HEP/Detectors/DetectorChamber.h"
+#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 #include "Math/Units.h"
 
 #include "Vtk/uLibVtkViewer.h"
@@ -43,20 +43,20 @@ BOOST_AUTO_TEST_CASE(vtkDetectorChamberTest) {
   d2.Scale(Vector3f(1_m, 2_m, 20_cm));
   d2.Translate(Vector3f(1_m, 0, 10_m));
 
-  Vtk::vtkDetectorChamber v_d1(&d1);
+  Vtk::DetectorChamber v_d1(&d1);
-  Vtk::vtkDetectorChamber v_d2(&d2);
+  Vtk::DetectorChamber v_d2(&d2);
-  v_d1.SetRepresentation(Vtk::Puppet::Surface);
+  v_d1.SetRepresentation(Vtk::Prop3D::Surface);
-  v_d2.SetRepresentation(Vtk::Puppet::Surface);
+  v_d2.SetRepresentation(Vtk::Prop3D::Surface);
 
   if (!v_d1.GetProp()) {
-    BOOST_FAIL("vtkDetectorChamber::GetProp() returned NULL");
+    BOOST_FAIL("DetectorChamber::GetProp() returned NULL");
   }
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
     viewer.SetGridAxis(Vtk::Viewport::Y);
-    viewer.AddPuppet(v_d1);
+    viewer.AddProp3D(v_d1);
-    viewer.AddPuppet(v_d2);
+    viewer.AddProp3D(v_d2);
     viewer.Start();
   }
 

src/Vtk/HEP/Detectors/testing/vtkDetectorMuonProjectionTest.cpp

@@ -23,8 +23,8 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-#include "HEP/Detectors/DetectorChamber.h"
+#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
-#include "HEP/Detectors/MuonScatter.h"
+#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
 #include "Math/Units.h"
 #include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 #include "Vtk/HEP/Detectors/vtkMuonScatter.h"
@@ -42,10 +42,10 @@
 
 using namespace uLib;
 
-// A simple puppet class to represent an arrow indicative of a projected muon hit
+// A simple prop3d class to represent an arrow indicative of a projected muon hit
-class vtkArrowPuppet : public Vtk::Puppet {
+class vtkArrowProp3D : public Vtk::Prop3D {
 public:
-  vtkArrowPuppet() : m_Actor(vtkActor::New()) {
+  vtkArrowProp3D() : m_Actor(vtkActor::New()) {
     vtkNew<vtkArrowSource> arrow;
     vtkNew<vtkPolyDataMapper> mapper;
     mapper->SetInputConnection(arrow->GetOutputPort());
@@ -54,7 +54,7 @@ public:
     m_Actor->GetProperty()->SetColor(1, 1, 0); // Yellow color for visibility
   }
 
-  virtual ~vtkArrowPuppet() { m_Actor->Delete(); }
+  virtual ~vtkArrowProp3D() { m_Actor->Delete(); }
 
   void SetProjection(const HLine3f &line) {
     HPoint3f p = line.origin;
@@ -125,30 +125,30 @@ BOOST_AUTO_TEST_CASE(vtkDetectorMuonProjectionTest) {
   MuonEvent mu_proj1 = d1.ProjectMuonEvent(mu_event);
   MuonEvent mu_proj2 = d2.ProjectMuonEvent(mu_event);
 
-  Vtk::vtkDetectorChamber v_d1(&d1);
+  Vtk::DetectorChamber v_d1(&d1);
-  Vtk::vtkDetectorChamber v_d2(&d2);
+  Vtk::DetectorChamber v_d2(&d2);
-  Vtk::vtkMuonScatter v_event(event);
+  Vtk::MuonScatter v_event(event);
   v_event.AddPocaPoint(HPoint3f(0, 0, 0));
   v_event.SetColor(1, 0, 0); // Red muon event
 
-  v_d1.SetRepresentation(Vtk::Puppet::Surface);
+  v_d1.SetRepresentation(Vtk::Prop3D::Surface);
   v_d1.SetOpacity(0.3);
-  v_d2.SetRepresentation(Vtk::Puppet::Surface);
+  v_d2.SetRepresentation(Vtk::Prop3D::Surface);
   v_d2.SetOpacity(0.3);
 
   // 5. Add two arrows to mark where the projection is located on the chambers
-  vtkArrowPuppet v_p1, v_p2;
+  vtkArrowProp3D v_p1, v_p2;
   v_p1.SetProjection(mu_proj1.LineIn());
   v_p2.SetProjection(mu_proj2.LineIn());
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
     viewer.SetGridAxis(Vtk::Viewport::Z);
-    viewer.AddPuppet(v_d1);
+    viewer.AddProp3D(v_d1);
-    viewer.AddPuppet(v_d2);
+    viewer.AddProp3D(v_d2);
-    viewer.AddPuppet(v_event);
+    viewer.AddProp3D(v_event);
-    viewer.AddPuppet(v_p1);
+    viewer.AddProp3D(v_p1);
-    viewer.AddPuppet(v_p2);
+    viewer.AddProp3D(v_p2);
     viewer.Start();
   }
 

src/Vtk/HEP/Detectors/testing/vtkMuonScatterTest.cpp

@@ -24,7 +24,7 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/HEP/Detectors/vtkMuonScatter.h"
-#include "HEP/Detectors/MuonScatter.h"
+#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
 
 #include "Vtk/uLibVtkViewer.h"
 
@@ -41,7 +41,7 @@ BOOST_AUTO_TEST_CASE(vtkMuonScatterTest) {
   event.LineOut().direction << 0, -1, 0, 0;
   event.LineOut().origin << 0, -1, 0, 1;
 
-  Vtk::vtkMuonScatter v_event(event);
+  Vtk::MuonScatter v_event(event);
   v_event.AddPocaPoint(HPoint3f(0, 0, 0));
 
   v_event.SaveToXMLFile("vtk_testing_muonevent.vtp");
@@ -49,12 +49,12 @@ BOOST_AUTO_TEST_CASE(vtkMuonScatterTest) {
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
 
-    //    Vtk::Tie<Vtk::vtkMuonScatter> tms;
+    //    Vtk::Tie<Vtk::MuonScatter> tms;
     //    tms.DoAction();
     //    Vtk::Tie<Vtk::Viewer> vms;
     //    vms.DoAction();
 
-    viewer.AddPuppet(v_event);
+    viewer.AddProp3D(v_event);
     viewer.Start();
   }
 

src/Vtk/HEP/Detectors/vtkDetectorChamber.cxx

@@ -48,8 +48,8 @@
 namespace uLib {
 namespace Vtk {
 
-vtkDetectorChamber::vtkDetectorChamber(DetectorChamber *content)
+DetectorChamber::DetectorChamber(uLib::DetectorChamber *content)
-    : vtkContainerBox(content) {
+    : ContainerBox(content) {
   m_PlaneSource = vtkPlaneSource::New();
   
   vtkNew<vtkPolyDataMapper> mapper;
@@ -67,20 +67,20 @@ vtkDetectorChamber::vtkDetectorChamber(DetectorChamber *content)
   this->Update();
 }
 
-vtkDetectorChamber::~vtkDetectorChamber() {
+DetectorChamber::~DetectorChamber() {
   m_PlaneSource->Delete();
   m_PlaneActor->Delete();
 }
 
-DetectorChamber *vtkDetectorChamber::GetContent() {
+DetectorChamber::Content *DetectorChamber::GetContent() const {
-  return static_cast<DetectorChamber *>(m_Content);
+  return static_cast<Content *>(this->m_model.get());
 }
 
-void vtkDetectorChamber::Update() {
+void DetectorChamber::Update() {
   this->BaseClass::Update();
 
-  if (!m_Content) return;
+  if (!this->m_model) return;
-  DetectorChamber *c = this->GetContent();
+  Content *c = this->GetContent();
   Vector3f size = c->GetSize();
   HLine3f plane = c->GetProjectionPlane();
 

src/Vtk/HEP/Detectors/vtkDetectorChamber.h

@@ -32,7 +32,7 @@
 #include <vtkTransform.h>
 
 #include "HEP/Detectors/DetectorChamber.h"
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Vtk/uLibVtkInterface.h"
 #include "Vtk/Math/vtkContainerBox.h"
 #include <vtkActor.h>
@@ -44,17 +44,17 @@ class vtkPlaneSource;
 namespace uLib {
 namespace Vtk {
 
-// class vtkHandlerWidget; // Removed as we use vtkBoxWidget now
+// class HandlerWidget; // Removed as we use vtkBoxWidget now
 
-class vtkDetectorChamber : public vtkContainerBox {
+class DetectorChamber : public ContainerBox {
-  typedef DetectorChamber Content;
+  typedef uLib::DetectorChamber Content;
-  typedef vtkContainerBox BaseClass;
+  typedef ContainerBox BaseClass;
 
 public:
-  vtkDetectorChamber(DetectorChamber *content);
+  DetectorChamber(uLib::DetectorChamber *content);
-  virtual ~vtkDetectorChamber();
+  virtual ~DetectorChamber();
 
-  Content *GetContent();
+  Content *GetContent() const override;
 
   virtual void Update() override;
 

src/Vtk/HEP/Detectors/vtkMuonEvent.cxx

@@ -27,7 +27,7 @@
 #include "config.h"
 #endif
 
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Vtk/HEP/Detectors/vtkMuonEvent.h"
 
 namespace uLib {
@@ -38,7 +38,7 @@ namespace Vtk {
 class vtkWidgetCallback : public vtkCommand {
 public:
   static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
-  void SetParent(uLib::Vtk::vtkMuonEvent *parent) { this->parent = parent; }
+  void SetParent(uLib::Vtk::MuonEvent *parent) { this->parent = parent; }
   virtual void Execute(vtkObject *caller, unsigned long, void *) {
     vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
     vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget *>(caller);
@@ -48,30 +48,30 @@ public:
   }
 
 private:
-  uLib::Vtk::vtkMuonEvent *parent;
+  uLib::Vtk::MuonEvent *parent;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 /////  VTK MUON EVENT  /////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-vtkMuonEvent::vtkMuonEvent(MuonEventData &content)
+MuonEvent::MuonEvent(MuonEventData &content)
     : m_PolyData(NULL), m_Appender(vtkAppendPolyData::New()),
       content(&content) {
   InstallPipe();
 }
 
-vtkMuonEvent::vtkMuonEvent(const MuonEventData &content)
+MuonEvent::MuonEvent(const MuonEventData &content)
     : m_PolyData(NULL), m_Appender(vtkAppendPolyData::New()),
       content(const_cast<MuonEventData *>(&content)) {
   InstallPipe();
 }
 
-vtkMuonEvent::~vtkMuonEvent() {}
+MuonEvent::~MuonEvent() {}
 
-vtkMuonEvent::Content &vtkMuonEvent::GetContent() { return *content; }
+MuonEventData &MuonEvent::GetModel() { return *content; }
 
-void vtkMuonEvent::PrintSelf(std::ostream &o) const {
+void MuonEvent::PrintSelf(std::ostream &o) const {
   o << "..:: MuonEvent ::..\n"
        "\t[in]  Origin    > "
     << content->LineIn().origin.transpose() << "\n"
@@ -83,7 +83,7 @@ void vtkMuonEvent::PrintSelf(std::ostream &o) const {
     << "...................\n";
 }
 
-void vtkMuonEvent::InstallPipe() {
+void MuonEvent::InstallPipe() {
 
   vtkAppendPolyData *appender = m_Appender;
   vtkSmartPointer<vtkPolyDataMapper> mapper =
@@ -121,11 +121,11 @@ void vtkMuonEvent::InstallPipe() {
   this->SetProp(actor);
 }
 
-vtkPolyData *vtkMuonEvent::GetPolyData() const {
+vtkPolyData *MuonEvent::GetPolyData() const {
   return m_Appender->GetOutput();
 }
 
-void vtkMuonEvent::AddPocaPoint(HPoint3f poca) {
+void MuonEvent::AddPocaPoint(HPoint3f poca) {
   m_Poca = poca;
   vtkSmartPointer<vtkSphereSource> sphere =
       vtkSmartPointer<vtkSphereSource>::New();
@@ -139,7 +139,8 @@ void vtkMuonEvent::AddPocaPoint(HPoint3f poca) {
   m_Appender->Update();
 }
 
-HPoint3f vtkMuonEvent::GetPocaPoint() { return m_Poca; }
+HPoint3f MuonEvent::GetPocaPoint() { return m_Poca; }
 
+uLib::Object* MuonEvent::GetContent() const { return (uLib::Object*)content; }
 } // namespace Vtk
 } // namespace uLib

src/Vtk/HEP/Detectors/vtkMuonEvent.h

@@ -41,7 +41,7 @@
 #include <vtkCommand.h>
 #include <vtkTransform.h>
 
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 
 #include "HEP/Detectors/MuonEvent.h"
 #include "Vtk/uLibVtkInterface.h"
@@ -50,19 +50,20 @@
 namespace uLib {
 namespace Vtk {
 
-class vtkMuonEvent : public Puppet, public Polydata {
+class MuonEvent : public Prop3D, public Polydata {
   typedef MuonEventData Content;
 
 public:
-  vtkMuonEvent(const MuonEventData &content);
+  MuonEvent(const MuonEventData &content);
-  vtkMuonEvent(MuonEventData &content);
+  MuonEvent(MuonEventData &content);
-  ~vtkMuonEvent();
+  ~MuonEvent();
 
-  Content &GetContent();
+  Content &GetModel();
+  uLib::Object* GetContent() const override;
 
-  void PrintSelf(std::ostream &o) const;
+  void PrintSelf(std::ostream &o) const override;
 
-  virtual vtkPolyData *GetPolyData() const;
+  vtkPolyData *GetPolyData() const override;
 
   void AddPocaPoint(HPoint3f poca);
 
@@ -73,7 +74,7 @@ public:
 private:
   void InstallPipe();
 
-  vtkMuonEvent::Content *content;
+  MuonEvent::Content *content;
   vtkPolyData *m_PolyData;
 
   vtkAppendPolyData *m_Appender;

src/Vtk/HEP/Detectors/vtkMuonScatter.cxx

@@ -27,7 +27,7 @@
 #include "config.h"
 #endif
 
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Vtk/HEP/Detectors/vtkMuonScatter.h"
 
 namespace uLib {
@@ -37,21 +37,21 @@ namespace Vtk {
 /////  VTK MUON Scatter  ///////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-vtkMuonScatter::vtkMuonScatter(MuonScatter &content)
+MuonScatter::MuonScatter(uLib::MuonScatter &content)
     : m_Content(&content), m_LineIn(vtkLineSource::New()),
       m_LineOut(vtkLineSource::New()), m_PolyData(vtkPolyData::New()),
       m_SpherePoca(NULL), m_Asm(vtkAssembly::New()) {
   InstallPipe();
 }
 
-vtkMuonScatter::vtkMuonScatter(const MuonScatter &content)
+MuonScatter::MuonScatter(const MuonScatter &content)
-    : m_Content(const_cast<MuonScatter *>(&content)),
+    : m_Content(content.m_Content),
       m_LineIn(vtkLineSource::New()), m_LineOut(vtkLineSource::New()),
       m_PolyData(vtkPolyData::New()), m_SpherePoca(NULL), m_Asm(vtkAssembly::New()) {
   InstallPipe();
 }
 
-vtkMuonScatter::~vtkMuonScatter() {
+MuonScatter::~MuonScatter() {
   m_LineIn->Delete();
   m_LineOut->Delete();
   m_Asm->Delete();
@@ -59,11 +59,11 @@ vtkMuonScatter::~vtkMuonScatter() {
     m_SpherePoca->Delete();
 }
 
-vtkMuonScatter::Content &vtkMuonScatter::GetContent() { return *m_Content; }
+MuonScatter::Content &MuonScatter::GetModel() { return *m_Content; }
 
-void vtkMuonScatter::PrintSelf(std::ostream &o) const {}
+void MuonScatter::PrintSelf(std::ostream &o) const {}
 
-void vtkMuonScatter::InstallPipe() {
+void MuonScatter::InstallPipe() {
   if (m_Content) {
     vtkLineSource *line_in = m_LineIn;
     vtkLineSource *line_out = m_LineOut;
@@ -99,7 +99,7 @@ void vtkMuonScatter::InstallPipe() {
   this->SetProp(m_Asm);
 }
 
-vtkPolyData *vtkMuonScatter::GetPolyData() const {
+vtkPolyData *MuonScatter::GetPolyData() const {
   vtkSmartPointer<vtkAppendPolyData> append =
       vtkSmartPointer<vtkAppendPolyData>::New();
   append->AddInputConnection(m_LineIn->GetOutputPort());
@@ -111,7 +111,7 @@ vtkPolyData *vtkMuonScatter::GetPolyData() const {
   return m_PolyData;
 }
 
-void vtkMuonScatter::AddPocaPoint(HPoint3f poca) {
+void MuonScatter::AddPocaPoint(HPoint3f poca) {
   vtkSphereSource *sphere = vtkSphereSource::New();
   float size =
       (m_Content->LineIn().origin - m_Content->LineOut().origin).head(3).norm();
@@ -129,7 +129,7 @@ void vtkMuonScatter::AddPocaPoint(HPoint3f poca) {
   m_Asm->AddPart(actor);
 }
 
-HPoint3f vtkMuonScatter::GetPocaPoint() {
+HPoint3f MuonScatter::GetPocaPoint() {
   double center[3];
   if (m_SpherePoca) {
     m_SpherePoca->GetCenter(center);
@@ -139,7 +139,7 @@ HPoint3f vtkMuonScatter::GetPocaPoint() {
   }
 }
 
-void vtkMuonScatter::ConnectInteractor(vtkRenderWindowInteractor *interactor) {
+void MuonScatter::ConnectInteractor(vtkRenderWindowInteractor *interactor) {
   // TODO
 }
 

src/Vtk/HEP/Detectors/vtkMuonScatter.h

@@ -43,7 +43,7 @@
 #include <vtkCommand.h>
 #include <vtkTransform.h>
 
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 
 #include "HEP/Detectors/MuonScatter.h"
 #include "Vtk/uLibVtkInterface.h"
@@ -54,20 +54,21 @@ class vtkRenderWindowInteractor;
 namespace uLib {
 namespace Vtk {
 
-class vtkMuonScatter : public Puppet, public Polydata {
+class MuonScatter : public Prop3D, public Polydata {
-  typedef MuonScatter Content;
+  typedef uLib::MuonScatter Content;
 
 public:
-  vtkMuonScatter(const MuonScatter &content);
+  MuonScatter(const MuonScatter &content);
-  vtkMuonScatter(MuonScatter &content);
+  MuonScatter(uLib::MuonScatter &content);
 
-  ~vtkMuonScatter();
+  ~MuonScatter();
 
-  Content &GetContent();
+  Content &GetModel();
+  uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
 
-  void PrintSelf(std::ostream &o) const;
+  void PrintSelf(std::ostream &o) const override;
 
-  virtual vtkPolyData *GetPolyData() const;
+  virtual vtkPolyData *GetPolyData() const override;
 
   void AddPocaPoint(HPoint3f poca);
 
@@ -76,12 +77,12 @@ public:
   void vtkStartInteractive();
 
 protected:
-  void ConnectInteractor(vtkRenderWindowInteractor *interactor);
+  void ConnectInteractor(vtkRenderWindowInteractor *interactor) override;
 
 private:
   void InstallPipe();
 
-  vtkMuonScatter::Content *m_Content;
+  MuonScatter::Content *m_Content;
   vtkLineSource *m_LineIn;
   vtkLineSource *m_LineOut;
   vtkSphereSource *m_SpherePoca;

src/Vtk/HEP/Geant/testing/vtkCylinderEmitterPrimaryTest.cpp

@@ -10,11 +10,11 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Geant/Solid.h"
-#include "HEP/Geant/GeantEvent.h"
+#include "Vtk/HEP/Geant/vtkGeantEvent.h"
 #include "HEP/Geant/Scene.h"
 #include "HEP/Geant/EmitterPrimary.hh"
-#include "Math/Cylinder.h"
+#include "Vtk/Math/vtkCylinder.h"
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Math/Units.h"
 #include "Vtk/uLibVtkViewer.h"
 #include "Vtk/HEP/Geant/vtkGeantEvent.h"
@@ -58,8 +58,8 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
             std::cout << "    Collected event " << lastEvent->GetEventID() 
                       << " with " << lastEvent->Path().size() << " steps." << std::endl;
                       
-            Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
+            Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
-            state->viewer->AddPuppet(*vtkEvent);
+            state->viewer->AddProp3D(*vtkEvent);
             
             state->viewer->GetRenderer()->Render();
             state->viewer->GetRenderWindow()->Render();
@@ -97,21 +97,21 @@ int main(int argc, char** argv) {
     Vtk::Viewer viewer;
     viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
     
-    Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
+    Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
     vtkWorld->ShowScaleMeasures(true);
-    vtkWorld->SetRepresentation(Vtk::Puppet::Wireframe);
+    vtkWorld->SetRepresentation(Vtk::Prop3D::Wireframe);
     vtkWorld->SetSelectable(false);
-    viewer.AddPuppet(*vtkWorld);
+    viewer.AddProp3D(*vtkWorld);
     
-    Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
+    Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
     vtkIron->SetOpacity(0.2);
-    vtkIron->SetRepresentation(Vtk::Puppet::Surface);
+    vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkIron);
+    viewer.AddProp3D(*vtkIron);
 
     // Use vtkCylinderEmitterPrimary
     Vtk::vtkCylinderEmitterPrimary* vtkEmitter = new Vtk::vtkCylinderEmitterPrimary(*emitter);
     vtkEmitter->SetSelectable(false);
-    viewer.AddPuppet(*vtkEmitter);
+    viewer.AddProp3D(*vtkEmitter);
     
     // 3. Event Handling
     AppState state = { &scene, &viewer, {} };

src/Vtk/HEP/Geant/testing/vtkEmitterPrimaryTest.cpp

@@ -1,15 +1,15 @@
 #include "Geant/Solid.h"
-#include "HEP/Geant/GeantEvent.h"
+#include "Vtk/HEP/Geant/vtkGeantEvent.h"
 #include "HEP/Geant/Scene.h"
 #include "HEP/Geant/EmitterPrimary.hh"
-#include "Math/ContainerBox.h"
+#include "Vtk/Math/vtkContainerBox.h"
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Math/Units.h"
 #include "Vtk/uLibVtkViewer.h"
 #include "Vtk/HEP/Geant/vtkGeantEvent.h"
 #include "Vtk/HEP/Geant/vtkEmitterPrimary.h"
 #include "Vtk/Math/vtkContainerBox.h"
-#include "HEP/Detectors/DetectorChamber.h"
+#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 #include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 
 #include <vtkSmartPointer.h>
@@ -51,8 +51,8 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
                       << " with " << lastEvent->Path().size() << " steps." << std::endl;
                       
             // Wrap it for VTK
-            Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
+            Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
-            state->viewer->AddPuppet(*vtkEvent);
+            state->viewer->AddProp3D(*vtkEvent);
             
             // Re-render
             state->viewer->GetRenderer()->Render();
@@ -105,35 +105,35 @@ int main(int argc, char** argv) {
     viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
     
     // Visualize world box
-    Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
+    Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
     vtkWorld->ShowScaleMeasures(true);
-    vtkWorld->SetRepresentation(Vtk::Puppet::Wireframe);
+    vtkWorld->SetRepresentation(Vtk::Prop3D::Wireframe);
     vtkWorld->SetSelectable(false);
-    viewer.AddPuppet(*vtkWorld);
+    viewer.AddProp3D(*vtkWorld);
     
     // Visualize iron cube
-    Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
+    Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
     vtkIron->SetOpacity(0.2);
-    vtkIron->SetRepresentation(Vtk::Puppet::Surface);
+    vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkIron);
+    viewer.AddProp3D(*vtkIron);
 
     // Visualize Top Chamber
-    Vtk::vtkDetectorChamber* vtkTop = new Vtk::vtkDetectorChamber(top_chamber_box);
+    Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box);
     vtkTop->SetOpacity(0.5);
     vtkTop->SetColor(0.2, 0.8, 0.2);
-    vtkTop->SetRepresentation(Vtk::Puppet::Surface);
+    vtkTop->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkTop);
+    viewer.AddProp3D(*vtkTop);
 
     // Visualize Bottom Chamber
-    Vtk::vtkDetectorChamber* vtkBottom = new Vtk::vtkDetectorChamber(bottom_chamber_box);
+    Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box);
     vtkBottom->SetOpacity(0.5);
     vtkBottom->SetColor(0.2, 0.8, 0.2);
-    vtkBottom->SetRepresentation(Vtk::Puppet::Surface);
+    vtkBottom->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkBottom);
+    viewer.AddProp3D(*vtkBottom);
 
     // Visualize Emitter
-    Vtk::vtkEmitterPrimary* vtkEmitter = new Vtk::vtkEmitterPrimary(*emitter);
+    Vtk::EmitterPrimary* vtkEmitter = new Vtk::EmitterPrimary(*emitter);
-    viewer.AddPuppet(*vtkEmitter);
+    viewer.AddProp3D(*vtkEmitter);
     
     // 3. Event Handling
     AppState state = { &scene, &viewer, {} };

src/Vtk/HEP/Geant/testing/vtkGeantEventTest.cpp

@@ -10,11 +10,11 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Geant/Solid.h"
-#include "HEP/Geant/GeantEvent.h"
+#include "Vtk/HEP/Geant/vtkGeantEvent.h"
 #include "HEP/Geant/Scene.h"
 #include "HEP/Geant/EmitterPrimary.hh"
-#include "Math/ContainerBox.h"
+#include "Vtk/Math/vtkContainerBox.h"
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Math/Units.h"
 #include "Vtk/uLibVtkViewer.h"
 #include "Vtk/HEP/Geant/vtkGeantEvent.h"
@@ -82,8 +82,8 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
                       << " with " << lastEvent->Path().size() << " steps." << std::endl;
                       
             // Wrap it for VTK
-            Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
+            Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
-            state->viewer->AddPuppet(*vtkEvent);
+            state->viewer->AddProp3D(*vtkEvent);
             
             // Re-render
             state->viewer->GetRenderer()->Render();
@@ -117,16 +117,16 @@ int main(int argc, char** argv) {
     viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
     
     // Visualize world box
-    Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
+    Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
     // vtkWorld->ShowBoundingBox(true);
     vtkWorld->ShowScaleMeasures(true);
-    viewer.AddPuppet(*vtkWorld);
+    viewer.AddProp3D(*vtkWorld);
     
     // Visualize iron cube
-    Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
+    Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
     vtkIron->SetOpacity(0.2);
-    vtkIron->SetRepresentation(Vtk::Puppet::Surface);
+    vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkIron);
+    viewer.AddProp3D(*vtkIron);
     
     // 3. Event Handling
     AppState state = { &scene, &viewer, {} };

src/Vtk/HEP/Geant/testing/vtkGeantSceneTest.cpp

@@ -11,8 +11,8 @@
 
 #include "Geant/Solid.h"
 #include "HEP/Geant/Scene.h"
-#include "Math/ContainerBox.h"
+#include "Vtk/Math/vtkContainerBox.h"
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Math/Units.h"
 #include "Vtk/uLibVtkViewer.h"
 #include "Vtk/HEP/Geant/vtkGeantScene.h"
@@ -46,11 +46,11 @@ int main(int argc, char** argv) {
     Vtk::Viewer viewer;
     viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
 
-    Vtk::vtkGeantScene vtkScene(&scene);
+    Vtk::GeantScene vtkScene(&scene);
     vtkScene.AddToViewer(viewer);
 
     std::cout << "==================================================" << std::endl;
-    std::cout << " vtkGeantScene Test" << std::endl;
+    std::cout << " GeantScene Test" << std::endl;
     std::cout << " World box + 1 iron cube displayed" << std::endl;
     std::cout << "==================================================" << std::endl;
 

src/Vtk/HEP/Geant/testing/vtkSkyPlaneEmitterPrimaryTest.cpp

@@ -1,15 +1,15 @@
 #include "Geant/Solid.h"
-#include "HEP/Geant/GeantEvent.h"
+#include "Vtk/HEP/Geant/vtkGeantEvent.h"
 #include "HEP/Geant/Scene.h"
 #include "HEP/Geant/EmitterPrimary.hh"
-#include "Math/ContainerBox.h"
+#include "Vtk/Math/vtkContainerBox.h"
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Math/Units.h"
 #include "Vtk/uLibVtkViewer.h"
 #include "Vtk/HEP/Geant/vtkGeantEvent.h"
 #include "Vtk/HEP/Geant/vtkEmitterPrimary.h"
 #include "Vtk/Math/vtkContainerBox.h"
-#include "HEP/Detectors/DetectorChamber.h"
+#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 #include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 
 #include <vtkSmartPointer.h>
@@ -49,8 +49,8 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
             std::cout << "    Collected event " << lastEvent->GetEventID() 
                       << " with " << lastEvent->Path().size() << " steps." << std::endl;
                       
-            Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
+            Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
-            state->viewer->AddPuppet(*vtkEvent);
+            state->viewer->AddProp3D(*vtkEvent);
             
             state->viewer->GetRenderer()->Render();
             state->viewer->GetRenderWindow()->Render();
@@ -107,35 +107,35 @@ int main(int argc, char** argv) {
     Vtk::Viewer viewer;
     viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
     
-    Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
+    Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
     vtkWorld->ShowScaleMeasures(true);
-    vtkWorld->SetRepresentation(Vtk::Puppet::Wireframe);
+    vtkWorld->SetRepresentation(Vtk::Prop3D::Wireframe);
     vtkWorld->SetSelectable(false);
-    viewer.AddPuppet(*vtkWorld);
+    viewer.AddProp3D(*vtkWorld);
     
-    Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
+    Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
     vtkIron->SetOpacity(0.2);
-    vtkIron->SetRepresentation(Vtk::Puppet::Surface);
+    vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkIron);
+    viewer.AddProp3D(*vtkIron);
 
     // Visualize Top Chamber
-    Vtk::vtkDetectorChamber* vtkTop = new Vtk::vtkDetectorChamber(top_chamber_box);
+    Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box);
     vtkTop->SetOpacity(0.5);
     vtkTop->SetColor(0.2, 0.8, 0.2);
-    vtkTop->SetRepresentation(Vtk::Puppet::Surface);
+    vtkTop->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkTop);
+    viewer.AddProp3D(*vtkTop);
 
     // Visualize Bottom Chamber
-    Vtk::vtkDetectorChamber* vtkBottom = new Vtk::vtkDetectorChamber(bottom_chamber_box);
+    Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box);
     vtkBottom->SetOpacity(0.5);
     vtkBottom->SetColor(0.2, 0.8, 0.2);
-    vtkBottom->SetRepresentation(Vtk::Puppet::Surface);
+    vtkBottom->SetRepresentation(Vtk::Prop3D::Surface);
-    viewer.AddPuppet(*vtkBottom);
+    viewer.AddProp3D(*vtkBottom);
 
-    // Use vtkSkyPlaneEmitterPrimary instead of vtkEmitterPrimary
+    // Use vtkSkyPlaneEmitterPrimary instead of EmitterPrimary
     Vtk::vtkSkyPlaneEmitterPrimary* vtkEmitter = new Vtk::vtkSkyPlaneEmitterPrimary(*emitter);
     vtkEmitter->SetSelectable(false);
-    viewer.AddPuppet(*vtkEmitter);
+    viewer.AddProp3D(*vtkEmitter);
     
     // 3. Event Handling
     AppState state = { &scene, &viewer, {} };

src/Vtk/HEP/Geant/testing/vtkSolidsTest.cpp

@@ -13,8 +13,8 @@
 #include "Vtk/HEP/Geant/vtkTessellatedSolid.h"
 #include "Vtk/uLibVtkViewer.h"
 #include "HEP/Geant/Solid.h"
-#include "Math/ContainerBox.h"
+#include "Vtk/Math/vtkContainerBox.h"
-#include "Math/TriangleMesh.h"
+#include "Vtk/Math/vtkTriangleMesh.h"
 #include "Math/Units.h"
 
 #include <vtkProperty.h>
@@ -31,7 +31,7 @@ int main(int argc, char** argv) {
     Geant::BoxSolid gBox("MyBox", &box);
     gBox.Update();
 
-    Vtk::vtkBoxSolid vtkBox(&gBox);
+    Vtk::BoxSolid vtkBox(&gBox);
 
     // 2. Create a TessellatedSolid
     Geant::TessellatedSolid gTess("MyTess");
@@ -53,7 +53,7 @@ int main(int argc, char** argv) {
     gTess.SetMesh(mesh);
     gTess.Update();
 
-    Vtk::vtkTessellatedSolid vtkTess(&gTess);
+    Vtk::TessellatedSolid vtkTess(&gTess);
 
     // 3. Visualization setup
     Vtk::Viewer viewer;
@@ -61,8 +61,8 @@ int main(int argc, char** argv) {
     vtkTess.AddToViewer(viewer);
 
     // Color them differently
-    vtkActor::SafeDownCast(vtkBox.GetProp())->GetProperty()->SetColor(0.8, 0.2, 0.2); // Redish box
+    vtkBox.SetColor(0.8, 0.2, 0.2);  // Redish box
-    vtkActor::SafeDownCast(vtkTess.GetProp())->GetProperty()->SetColor(0.2, 0.8, 0.2); // Greenish tess
+    vtkTess.SetColor(0.2, 0.8, 0.2); // Greenish tess
     
     // Position tessellated solid away from box
     Matrix4f trans = Matrix4f::Identity();

src/Vtk/HEP/Geant/vtkBoxSolid.cpp

@@ -10,48 +10,75 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "vtkBoxSolid.h"
+#include "Core/Monitor.h"
 #include <vtkCubeSource.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
+#include <vtkProperty.h>
+#include <vtkAssembly.h>
+#include <vtkTransform.h>
+#include <vtkMatrix4x4.h>
+#include <Geant4/G4VPhysicalVolume.hh>
+#include "Vtk/Math/vtkDense.h"
 
 namespace uLib {
 namespace Vtk {
 
-vtkBoxSolid::vtkBoxSolid(Geant::BoxSolid *content)
+BoxSolid::BoxSolid(Geant::BoxSolid *content)
-    : vtkGeantSolid(content), m_BoxContent(content) {
+    : GeantSolid(content), m_BoxContent(content) {
-  // Re-run Update for box-specific pipe
+  this->InstallPipe();
+ 
+  // Connect the model's Updated event to updateTransform to ensure VTK sync
+  m_UpdateConnection = Object::connect(m_BoxContent, &uLib::Object::Updated, this, &BoxSolid::Update);
+
+  // Initial sync
   this->Update();
 }
 
-vtkBoxSolid::~vtkBoxSolid() {}
+BoxSolid::~BoxSolid() {
-
-void vtkBoxSolid::Update() {
-  this->UpdateGeometry();
-  this->UpdateTransform();
 }
 
-void vtkBoxSolid::UpdateGeometry() {
+void BoxSolid::Update() {
-  if (!m_BoxContent || !m_BoxContent->GetObject()) {
+  ConnectionBlock blocker(m_UpdateConnection);
-    // Fallback to base tessellation if no model object
+  this->UpdateGeometry();
-    vtkGeantSolid::UpdateGeometry();
+  // Ensure base Prop3D properties (color, opacity, etc) and transform are applied
-    return;
+  this->Prop3D::Update();
+}
+
+void BoxSolid::SyncFromVtk() {
+  this->Prop3D::SyncFromVtk();
+  if (auto* proxy = vtkProp3D::SafeDownCast(this->GetProxyProp())) {
+      if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
+          m_BoxContent->SetTransform(VtkToMatrix4f(mat));
       }
-
-  // Use the underlying ContainerBox for precise geometry
-  Vector3f size = m_BoxContent->GetObject()->GetSize();
-  
-  vtkNew<vtkCubeSource> cube;
-  cube->SetXLength(size(0));
-  cube->SetYLength(size(1));
-  cube->SetZLength(size(2));
-  cube->Update();
-
-  vtkPolyData *poly = GetPolyData();
-  if (poly) {
-      poly->ShallowCopy(cube->GetOutput());
-      poly->Modified();
   }
 }
 
+void BoxSolid::UpdateGeometry() {
+  // Sync geometry from G4VSolid provided by GeantSolid (tessellation)
+  GeantSolid::UpdateGeometry();
+}
+
+void BoxSolid::UpdateTransform() {
+  // Take transform from Prop3D base (which uses GetContent() -> ContainerBox TRS)
+  this->Prop3D::Update();
+}
+
+void BoxSolid::serialize_display(uLib::Archive::display_properties_archive &ar,
+                                    const unsigned int version) {
+  // Expose Geant solid properties and underlying Box/TRS properties
+  this->Prop3D::serialize_display(ar, version);
+  if (m_BoxContent) {
+    ar & NVP("Box", *m_BoxContent);
+    if (m_BoxContent->GetObject()) {
+      ar & NVP("Container", *m_BoxContent->GetObject());
+    }
+  }
+}
+
+void BoxSolid::InstallPipe() {
+  GeantSolid::InstallPipe();
+}
+
 } // namespace Vtk
 } // namespace uLib

src/Vtk/HEP/Geant/vtkBoxSolid.h

@@ -26,24 +26,52 @@
 #ifndef U_VTKBOXSOLID_H
 #define U_VTKBOXSOLID_H
 
+#include "Core/Types.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
+
 #include "vtkGeantSolid.h"
 
+class vtkCubeSource;
+class vtkActor;
+
 namespace uLib {
 namespace Vtk {
 
 /**
- * @brief VTK Puppet for visualizing a Geant::BoxSolid.
+ * @brief VTK Prop3D for visualizing a Geant::BoxSolid.
  */
-class vtkBoxSolid : public vtkGeantSolid {
+class BoxSolid : public GeantSolid {
+  uLibTypeMacro(BoxSolid, uLib::Vtk::GeantSolid)
+
 public:
-  vtkBoxSolid(Geant::BoxSolid *content);
+  BoxSolid(Geant::BoxSolid *content);
-  virtual ~vtkBoxSolid();
+  virtual ~BoxSolid();
 
   virtual void Update() override;
   virtual void UpdateGeometry() override;
+  virtual void UpdateTransform() override;
+  virtual void SyncFromVtk() override;
+
+  virtual uLib::Object *GetContent() const override { 
+    return m_BoxContent ? (::uLib::Object*)m_BoxContent->GetObject() : nullptr; 
+  }
+
+  virtual void serialize_display(uLib::Archive::display_properties_archive &ar,
+                                 const unsigned int version = 0) override;
+
+  template <typename Ar>
+  void serialize(Ar &ar, const unsigned int version) {
+    ar & NVP("BoxSolid", *m_BoxContent);
+  }
 
 protected:
+  virtual void InstallPipe() override;
+
   Geant::BoxSolid *m_BoxContent;
+  uLib::Connection m_UpdateConnection;
+
+  ULIB_DECLARE_PROPERTIES(BoxSolid)
 };
 
 } // namespace Vtk

src/Vtk/HEP/Geant/vtkEmitterPrimary.cpp

@@ -11,12 +11,12 @@
 #include <vtkPolyData.h>
 #include <vtkProperty.h>
 #include <vtkCylinderSource.h>
-#include "Math/vtkDense.h"
+#include "Vtk/Math/vtkDense.h"
 
 namespace uLib {
 namespace Vtk {
 
-vtkEmitterPrimary::vtkEmitterPrimary(Geant::EmitterPrimary &emitter)
+EmitterPrimary::EmitterPrimary(Geant::EmitterPrimary &emitter)
     : m_emitter(emitter), m_Actor(vtkActor::New()) {
     
     vtkNew<vtkArrowSource> arrow;
@@ -43,16 +43,16 @@ vtkEmitterPrimary::vtkEmitterPrimary(Geant::EmitterPrimary &emitter)
 
     this->SetProp(m_Actor);
     
-    Object::connect(&m_emitter, &Object::Updated, this, &vtkEmitterPrimary::contentUpdate);
+    Object::connect(&m_emitter, &Object::Updated, this, &EmitterPrimary::contentUpdate);
     this->contentUpdate();
 }
 
-vtkEmitterPrimary::~vtkEmitterPrimary() {
+EmitterPrimary::~EmitterPrimary() {
-    Object::disconnect(&m_emitter, &Object::Updated, this, &vtkEmitterPrimary::contentUpdate);
+    Object::disconnect(&m_emitter, &Object::Updated, this, &EmitterPrimary::contentUpdate);
     m_Actor->Delete();
 }
 
-void vtkEmitterPrimary::contentUpdate() {
+void EmitterPrimary::contentUpdate() {
     vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
     if (!vmat) {
         vtkNew<vtkMatrix4x4> mat;
@@ -63,10 +63,10 @@ void vtkEmitterPrimary::contentUpdate() {
     Matrix4f transform = m_emitter.GetWorldMatrix();
     Matrix4fToVtk(transform, vmat);
 
-    Puppet::Update();
+    Prop3D::Update();
 }
 
-void vtkEmitterPrimary::Update() {
+void EmitterPrimary::Update() {
     vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
     if (!vmat) return;
 
@@ -79,7 +79,7 @@ void vtkEmitterPrimary::Update() {
 // vtkSkyPlaneEmitterPrimary
 
 vtkSkyPlaneEmitterPrimary::vtkSkyPlaneEmitterPrimary(Geant::SkyPlaneEmitterPrimary &emitter)
-    : vtkEmitterPrimary(emitter), m_skyEmitter(emitter), m_PlaneSource(vtkPlaneSource::New()) {
+    : EmitterPrimary(emitter), m_skyEmitter(emitter), m_PlaneSource(vtkPlaneSource::New()) {
     
     vtkNew<vtkAppendPolyData> append;
     // Base class constructor already set an arrow. We keep it as a directional indicator.
@@ -107,27 +107,27 @@ void vtkSkyPlaneEmitterPrimary::contentUpdate() {
     m_PlaneSource->SetPoint2(-size(0)/2.0,  size(1)/2.0, 0.0);
     m_PlaneSource->Update();
 
-    vtkEmitterPrimary::contentUpdate();
+    EmitterPrimary::contentUpdate();
 }
 
 // -------------------------------------------------------------------------- //
 // vtkQuadMeshEmitterPrimary
 
 vtkQuadMeshEmitterPrimary::vtkQuadMeshEmitterPrimary(Geant::QuadMeshEmitterPrimary &emitter)
-    : vtkEmitterPrimary(emitter), m_meshEmitter(emitter) {
+    : EmitterPrimary(emitter), m_meshEmitter(emitter) {
     this->contentUpdate();
 }
 
 void vtkQuadMeshEmitterPrimary::contentUpdate() {
     // For now stick with the arrow. In the future visualize the mesh if useful.
-    vtkEmitterPrimary::contentUpdate();
+    EmitterPrimary::contentUpdate();
 }
  
 // -------------------------------------------------------------------------- //
 // vtkCylinderEmitterPrimary
 
 vtkCylinderEmitterPrimary::vtkCylinderEmitterPrimary(Geant::CylinderEmitterPrimary &emitter)
-    : vtkEmitterPrimary(emitter), m_cylinderEmitter(emitter), m_CylinderSource(vtkCylinderSource::New()) {
+    : EmitterPrimary(emitter), m_cylinderEmitter(emitter), m_CylinderSource(vtkCylinderSource::New()) {
     
     // vtkCylinderSource is along Y by default.
     // We will update its actual dimensions in contentUpdate().
@@ -170,7 +170,7 @@ void vtkCylinderEmitterPrimary::contentUpdate() {
     m_CylinderSource->SetCenter(0, h/2.0, 0);
     m_CylinderSource->Update();
 
-    vtkEmitterPrimary::contentUpdate();
+    EmitterPrimary::contentUpdate();
 }
 
 } // namespace Vtk

src/Vtk/HEP/Geant/vtkEmitterPrimary.h

@@ -14,10 +14,10 @@ class vtkCylinderSource;
 namespace uLib {
 namespace Vtk {
 
-class vtkEmitterPrimary : public Puppet {
+class EmitterPrimary : public Prop3D {
 public:
-    vtkEmitterPrimary(Geant::EmitterPrimary &emitter);
+    EmitterPrimary(Geant::EmitterPrimary &emitter);
-    virtual ~vtkEmitterPrimary();
+    virtual ~EmitterPrimary();
 
     virtual void contentUpdate();
     virtual void Update();
@@ -27,7 +27,7 @@ protected:
     vtkActor *m_Actor;
 };
 
-class vtkSkyPlaneEmitterPrimary : public vtkEmitterPrimary {
+class vtkSkyPlaneEmitterPrimary : public EmitterPrimary {
 public:
     vtkSkyPlaneEmitterPrimary(Geant::SkyPlaneEmitterPrimary &emitter);
     virtual ~vtkSkyPlaneEmitterPrimary();
@@ -41,7 +41,7 @@ private:
 
 
 
-class vtkQuadMeshEmitterPrimary : public vtkEmitterPrimary {
+class vtkQuadMeshEmitterPrimary : public EmitterPrimary {
 public:
     vtkQuadMeshEmitterPrimary(Geant::QuadMeshEmitterPrimary &emitter);
     virtual void contentUpdate();
@@ -50,7 +50,7 @@ private:
     Geant::QuadMeshEmitterPrimary &m_meshEmitter;
 };
 
-class vtkCylinderEmitterPrimary : public vtkEmitterPrimary {
+class vtkCylinderEmitterPrimary : public EmitterPrimary {
 public:
     vtkCylinderEmitterPrimary(Geant::CylinderEmitterPrimary &emitter);
     virtual ~vtkCylinderEmitterPrimary();

src/Vtk/HEP/Geant/vtkGeantEvent.cpp

@@ -35,23 +35,23 @@
 namespace uLib {
 namespace Vtk {
 
-vtkGeantEvent::vtkGeantEvent(Content *content)
+GeantEvent::GeantEvent(Content *content)
     : m_MuonPath(vtkActor::New()), m_Content(content) {
   this->InstallPipe();
   this->Update();
 }
 
-vtkGeantEvent::~vtkGeantEvent() {
+GeantEvent::~GeantEvent() {
   m_MuonPath->Delete();
 }
 
-vtkPolyData *vtkGeantEvent::GetPolyData() const {
+vtkPolyData *GeantEvent::GetPolyData() const {
   if (!m_MuonPath || !m_MuonPath->GetMapper())
     return NULL;
   return vtkPolyData::SafeDownCast(m_MuonPath->GetMapper()->GetInput());
 }
 
-void vtkGeantEvent::Update() {
+void GeantEvent::Update() {
   if (!m_Content)
     return;
 
@@ -88,7 +88,7 @@ void vtkGeantEvent::Update() {
   }
 }
 
-void vtkGeantEvent::InstallPipe() {
+void GeantEvent::InstallPipe() {
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();

src/Vtk/HEP/Geant/vtkGeantEvent.h

@@ -34,16 +34,16 @@
 namespace uLib {
 namespace Vtk {
 
-class vtkGeantEvent : public Puppet, public Polydata {
+class GeantEvent : public Prop3D, public Polydata {
   typedef Geant::GeantEvent Content;
 
 public:
-  vtkGeantEvent(Content *content);
+  GeantEvent(Content *content);
-  ~vtkGeantEvent();
+  ~GeantEvent();
 
   virtual class vtkPolyData *GetPolyData() const override;
 
-  virtual void Update();
+  virtual void Update() override;
 
 protected:
   virtual void InstallPipe();

src/Vtk/HEP/Geant/vtkGeantScene.cpp

@@ -32,20 +32,20 @@
 namespace uLib {
 namespace Vtk {
 
-vtkGeantScene::vtkGeantScene(Geant::Scene *scene)
+GeantScene::GeantScene(Geant::Scene *scene)
-    : m_Scene(scene), m_WorldPuppet(nullptr) {
+    : m_Scene(scene), m_WorldProp3D(nullptr) {
   if (!m_Scene)
     return;
 
-  // 1. Create the world box wireframe puppet
+  // 1. Create the world box wireframe prop3d
-  ContainerBox *worldBox = m_Scene->GetWorldBox();
+  uLib::ContainerBox *worldBox = m_Scene->GetWorldBox();
   if (worldBox) {
-    m_WorldPuppet = new vtkContainerBox(worldBox);
+    m_WorldProp3D = new ContainerBox(worldBox);
-    m_WorldPuppet->SetRepresentation(Puppet::Wireframe);
+    m_WorldProp3D->SetRepresentation(Prop3D::Wireframe);
-    m_WorldPuppet->ShowScaleMeasures(true);
+    m_WorldProp3D->ShowScaleMeasures(true);
   }
 
-  // 2. Create puppets for each non-world solid
+  // 2. Create prop3ds for each non-world solid
   const Geant::Solid *world = m_Scene->GetWorld();
   const Vector<Geant::Solid *> &solids = m_Scene->GetSolids();
 
@@ -54,47 +54,47 @@ vtkGeantScene::vtkGeantScene(Geant::Scene *scene)
     if (solid == world)
       continue;
 
-    // Only create a puppet if the solid has a valid G4VSolid
+    // Only create a prop3d if the solid has a valid G4VSolid
     if (solid->GetG4Solid()) {
-      vtkGeantSolid *vtkSolid = nullptr;
+      GeantSolid *vtkSolid = nullptr;
       if (auto *box = dynamic_cast<Geant::BoxSolid *>(solid)) {
-        vtkSolid = new vtkBoxSolid(box);
+        vtkSolid = new BoxSolid(box);
       } else if (auto *tess = dynamic_cast<Geant::TessellatedSolid *>(solid)) {
-        vtkSolid = new vtkTessellatedSolid(tess);
+        vtkSolid = new TessellatedSolid(tess);
       } else {
-        vtkSolid = new vtkGeantSolid(solid);
+        vtkSolid = new GeantSolid(solid);
         vtkSolid->Update();
       }
       
       if (vtkSolid) {
-        m_SolidPuppets.push_back(vtkSolid);
+        m_SolidProp3Ds.push_back(vtkSolid);
       }
     }
   }
 }
 
-vtkGeantScene::~vtkGeantScene() {
+GeantScene::~GeantScene() {
-  delete m_WorldPuppet;
+  delete m_WorldProp3D;
-  for (auto *p : m_SolidPuppets) {
+  for (auto *p : m_SolidProp3Ds) {
     delete p;
   }
 }
 
-void vtkGeantScene::AddToViewer(Viewport &viewer) {
+void GeantScene::AddToViewer(Viewport &viewer) {
-  if (m_WorldPuppet) {
+  if (m_WorldProp3D) {
-    viewer.AddPuppet(*m_WorldPuppet);
+    viewer.AddProp3D(*m_WorldProp3D);
   }
-  for (auto *p : m_SolidPuppets) {
+  for (auto *p : m_SolidProp3Ds) {
-    viewer.AddPuppet(*p);
+    viewer.AddProp3D(*p);
   }
 }
 
-void vtkGeantScene::RemoveFromViewer(Viewport &viewer) {
+void GeantScene::RemoveFromViewer(Viewport &viewer) {
-  if (m_WorldPuppet) {
+  if (m_WorldProp3D) {
-    viewer.RemovePuppet(*m_WorldPuppet);
+    viewer.RemoveProp3D(*m_WorldProp3D);
   }
-  for (auto *p : m_SolidPuppets) {
+  for (auto *p : m_SolidProp3Ds) {
-    viewer.RemovePuppet(*p);
+    viewer.RemoveProp3D(*p);
   }
 }
 

src/Vtk/HEP/Geant/vtkGeantScene.h

@@ -36,14 +36,14 @@
 namespace uLib {
 namespace Vtk {
 
-class vtkGeantSolid;
+class GeantSolid;
 
 /**
- * @brief VTK Puppet representing the entire Geant::Scene.
+ * @brief VTK Prop3D representing the entire Geant::Scene.
  *
- * When constructed, it creates child puppets for the world box (as a
+ * When constructed, it creates child prop3ds for the world box (as a
- * vtkContainerBox wireframe) and for each non-world Solid in the scene
+ * ContainerBox wireframe) and for each non-world Solid in the scene
- * (as vtkGeantSolid surfaces).
+ * (as GeantSolid surfaces).
  *
  * Usage:
  * @code
@@ -53,32 +53,32 @@ class vtkGeantSolid;
  *   scene.Initialize();
  *
  *   Vtk::Viewer viewer;
- *   Vtk::vtkGeantScene vtkScene(&scene);
+ *   Vtk::GeantScene vtkScene(&scene);
  *   vtkScene.AddToViewer(viewer);
  *   viewer.Start();
  * @endcode
  */
-class vtkGeantScene : public Object {
+class GeantScene : public Object {
 public:
-  vtkGeantScene(Geant::Scene *scene);
+  GeantScene(Geant::Scene *scene);
-  ~vtkGeantScene();
+  ~GeantScene();
 
-  /// Add all puppets (world box + solids) to a viewer.
+  /// Add all prop3ds (world box + solids) to a viewer.
   void AddToViewer(class Viewport &viewer);
 
-  /// Remove all puppets from viewport.
+  /// Remove all prop3ds from viewport.
   void RemoveFromViewer(class Viewport &viewer);
 
-  /// Get the world box puppet 
+  /// Get the world box prop3d 
-  vtkContainerBox* GetWorldPuppet() const { return m_WorldPuppet; }
+  ContainerBox* GetWorldProp3D() const { return m_WorldProp3D; }
 
-  /// Get the solid puppets
+  /// Get the solid prop3ds
-  const std::vector<vtkGeantSolid*>& GetSolidPuppets() const { return m_SolidPuppets; }
+  const std::vector<GeantSolid*>& GetSolidProp3Ds() const { return m_SolidProp3Ds; }
 
 private:
   Geant::Scene             *m_Scene;
-  vtkContainerBox          *m_WorldPuppet;
+  ContainerBox          *m_WorldProp3D;
-  std::vector<vtkGeantSolid*> m_SolidPuppets;
+  std::vector<GeantSolid*> m_SolidProp3Ds;
 };
 
 } // namespace Vtk

src/Vtk/HEP/Geant/vtkGeantSolid.cpp

@@ -42,27 +42,27 @@
 namespace uLib {
 namespace Vtk {
 
-vtkGeantSolid::vtkGeantSolid(Content *content)
+GeantSolid::GeantSolid(Content *content)
     : m_SolidActor(vtkActor::New()), m_Content(content) {
   this->InstallPipe();
 }
 
-vtkGeantSolid::~vtkGeantSolid() {
+GeantSolid::~GeantSolid() {
   m_SolidActor->Delete();
 }
 
-vtkPolyData *vtkGeantSolid::GetPolyData() const {
+vtkPolyData *GeantSolid::GetPolyData() const {
   if (!m_SolidActor || !m_SolidActor->GetMapper())
     return NULL;
   return vtkPolyData::SafeDownCast(m_SolidActor->GetMapper()->GetInput());
 }
 
-void vtkGeantSolid::Update() {
+void GeantSolid::Update() {
   this->UpdateGeometry();
   this->UpdateTransform();
 }
 
-void vtkGeantSolid::UpdateGeometry() {
+void GeantSolid::UpdateGeometry() {
   if (!m_Content)
     return;
 
@@ -82,6 +82,7 @@ void vtkGeantSolid::UpdateGeometry() {
   int nVertices = polyhedron->GetNoVertices();
   for (int i = 1; i <= nVertices; ++i) {
     G4Point3D vtx = polyhedron->GetVertex(i);
+    
     points->InsertNextPoint(vtx.x(), vtx.y(), vtx.z());
   }
 
@@ -109,7 +110,7 @@ void vtkGeantSolid::UpdateGeometry() {
   }
 }
 
-void vtkGeantSolid::UpdateTransform() {
+void GeantSolid::UpdateTransform() {
   if (!m_Content || !m_SolidActor)
     return;
 
@@ -141,7 +142,7 @@ void vtkGeantSolid::UpdateTransform() {
   }
 }
 
-void vtkGeantSolid::InstallPipe() {
+void GeantSolid::InstallPipe() {
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();

src/Vtk/HEP/Geant/vtkGeantSolid.h

@@ -36,18 +36,18 @@ namespace uLib {
 namespace Vtk {
 
 /**
- * @brief VTK Puppet for visualizing a Geant::Solid.
+ * @brief VTK Prop3D for visualizing a Geant::Solid.
  *
  * Renders the G4VSolid geometry as a tessellated polydata surface.
  * Works with BoxSolid, TessellatedSolid, or any Solid that provides
  * a valid G4VSolid via GetG4Solid().
  */
-class vtkGeantSolid : public Puppet, public Polydata {
+class GeantSolid : public Prop3D, public Polydata {
   typedef Geant::Solid Content;
 
 public:
-  vtkGeantSolid(Content *content);
+  GeantSolid(Content *content);
-  ~vtkGeantSolid();
+  ~GeantSolid();
 
   virtual class vtkPolyData *GetPolyData() const override;
 

src/Vtk/HEP/Geant/vtkTessellatedSolid.cpp

@@ -18,22 +18,22 @@
 namespace uLib {
 namespace Vtk {
 
-vtkTessellatedSolid::vtkTessellatedSolid(Geant::TessellatedSolid *content)
+TessellatedSolid::TessellatedSolid(Geant::TessellatedSolid *content)
-    : vtkGeantSolid(content), m_TessContent(content) {
+    : GeantSolid(content), m_TessContent(content) {
   this->Update();
 }
 
-vtkTessellatedSolid::~vtkTessellatedSolid() {}
+TessellatedSolid::~TessellatedSolid() {}
 
-void vtkTessellatedSolid::Update() {
+void TessellatedSolid::Update() {
   this->UpdateGeometry();
   this->UpdateTransform();
 }
 
-void vtkTessellatedSolid::UpdateGeometry() {
+void TessellatedSolid::UpdateGeometry() {
   if (!m_TessContent || m_TessContent->GetMesh().Points().empty()) {
     // Fallback to base tessellation if no model mesh
-    vtkGeantSolid::UpdateGeometry();
+    GeantSolid::UpdateGeometry();
     return;
   }
 

src/Vtk/HEP/Geant/vtkTessellatedSolid.h

@@ -18,12 +18,12 @@ namespace uLib {
 namespace Vtk {
 
 /**
- * @brief VTK Puppet for visualizing a Geant::TessellatedSolid.
+ * @brief VTK Prop3D for visualizing a Geant::TessellatedSolid.
  */
-class vtkTessellatedSolid : public vtkGeantSolid {
+class TessellatedSolid : public GeantSolid {
 public:
-  vtkTessellatedSolid(Geant::TessellatedSolid *content);
+  TessellatedSolid(Geant::TessellatedSolid *content);
-  virtual ~vtkTessellatedSolid();
+  virtual ~TessellatedSolid();
 
   virtual void Update() override;
   virtual void UpdateGeometry() override;

src/Vtk/HEP/MuonTomography/testing/vtkVoxRaytracerTest.cpp

@@ -46,7 +46,7 @@ class vtkWidgetCallback : public vtkCommand {
 public:
   static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
 
-  void SetTracer(Vtk::vtkVoxRaytracerRepresentation *parent) {
+  void SetTracer(Vtk::VoxRaytracerRepresentation *parent) {
     this->vtk_raytr = parent;
   }
 
@@ -74,7 +74,7 @@ private:
   vtkWidgetCallback() : vtk_raytr(NULL), muon(NULL), annotation(NULL) {}
 
   uLib::VoxRaytracer *raytracer;
-  Vtk::vtkVoxRaytracerRepresentation *vtk_raytr;
+  Vtk::VoxRaytracerRepresentation *vtk_raytr;
   uLib::MuonScatter *muon;
   vtkCornerAnnotation *annotation;
 };
@@ -87,14 +87,14 @@ BOOST_AUTO_TEST_CASE(vtkVoxRaytracerRepresentationTest) {
   muon.LineOut().origin << 6, -4, 6, 1;
   muon.LineOut().direction << 1, -1, 1, 0;
 
-  Vtk::vtkMuonScatter v_muon(muon);
+  Vtk::MuonScatter v_muon(muon);
 
   // structured grid //
   StructuredGrid grid(Vector3i(12, 10, 12));
   grid.SetSpacing(Vector3f(1, 1, 1));
   grid.SetPosition(Vector3f(0, 0, 0));
 
-  Vtk::vtkStructuredGrid v_grid(grid);
+  Vtk::StructuredGrid v_grid(&grid);
 
   // voxraytracer //
   VoxRaytracer rt(grid);
@@ -102,7 +102,7 @@ BOOST_AUTO_TEST_CASE(vtkVoxRaytracerRepresentationTest) {
   rt.GetEntryPoint(muon.LineIn(), pt);
   std::cout << pt.transpose() << "\n";
 
-  Vtk::vtkVoxRaytracerRepresentation v_rt(rt);
+  Vtk::VoxRaytracerRepresentation v_rt(rt);
   v_rt.SetMuon(muon);
   v_rt.SetRayColor(Vector4f(1, 0, 0, 1));
 
@@ -110,12 +110,12 @@ BOOST_AUTO_TEST_CASE(vtkVoxRaytracerRepresentationTest) {
     // renderer //
     Vtk::Viewer viewer;
 
-    viewer.AddPuppet(v_grid);
+    viewer.AddProp3D(v_grid);
-    viewer.AddPuppet(v_rt);
+    viewer.AddProp3D(v_rt);
-    viewer.AddPuppet(v_muon);
+    viewer.AddProp3D(v_muon);
     
     // Select grid to show handler widget
-    viewer.SelectPuppet(&v_grid);
+    viewer.SelectProp3D(&v_grid);
     
     viewer.Start();
   }

src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.h

@@ -30,7 +30,7 @@
 
 
 
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 
 #include "uLibVtkInterface.h"
 #include "Detectors/MuonScatter.h"
@@ -39,11 +39,11 @@ class vtkRenderWindowInteractor;
 
 namespace uLib {
 
-class vtkMuonContainerScattering : public Abstract::uLibVtkPolydata {
+class MuonContainerScattering : public Abstract::uLibVtkPolydata {
-    typedef MuonScatter Content;
+    typedef uLib::MuonScatter Content;
 public:
-    vtkMuonContainerScattering(const MuonScatter &content);
+    MuonContainerScattering(const MuonScatter &content);
-    ~vtkMuonScatter();
+    ~MuonScatter();
 
     Content& GetContent();
 

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.cpp

@@ -41,7 +41,7 @@ namespace Vtk {
 ////// VOX RAYTRACER REPRESENTATION  ///////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
+VoxRaytracerRepresentation::VoxRaytracerRepresentation(Content &content)
     : m_Content(&content),
       m_Sphere1(vtkSphereSource::New()), m_Sphere2(vtkSphereSource::New()),
       m_Line1(vtkLineSource::New()), m_Line2(vtkLineSource::New()),
@@ -51,6 +51,7 @@ vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
       m_RayRepresentationActor(vtkActor::New()),
       m_Transform(vtkTransform::New()),
       m_Asm(vtkAssembly::New()),
+      m_Muon(nullptr),
       m_HasMuon(false), m_HasPoca(false) {
   default_radius = content.GetImage()->GetSpacing()(0) / 4;
   m_Sphere1->SetRadius(default_radius);
@@ -61,48 +62,49 @@ vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
   InstallPipe();
   
   if (m_Content && m_Content->GetImage()) {
-      Object::connect(m_Content->GetImage(), &StructuredGrid::Updated, this, &vtkVoxRaytracerRepresentation::imageUpdate);
+      Object::connect(m_Content->GetImage(), &StructuredGrid::Updated, this, &VoxRaytracerRepresentation::imageUpdate);
   }
 }
 
-vtkVoxRaytracerRepresentation::~vtkVoxRaytracerRepresentation() {
+VoxRaytracerRepresentation::~VoxRaytracerRepresentation() {
   m_RayLine->Delete();
   m_RayLineActor->Delete();
   m_RayRepresentationActor->Delete();
   m_Transform->Delete();
+  if (m_Muon) delete m_Muon;
 }
 
-uLib::VoxRaytracer *vtkVoxRaytracerRepresentation::GetRaytracerAlgorithm() {
+uLib::VoxRaytracer *VoxRaytracerRepresentation::GetRaytracerAlgorithm() {
   return m_Content;
 }
 
-void vtkVoxRaytracerRepresentation::Update() {
+void VoxRaytracerRepresentation::Update() {
    this->imageUpdate();
 }
 
-void vtkVoxRaytracerRepresentation::imageUpdate() {
+void VoxRaytracerRepresentation::imageUpdate() {
-   if (m_HasMuon) {
+   if (m_HasMuon && m_Muon) {
        if (m_HasPoca) {
-           this->SetMuon(m_Muon, m_Poca);
+           this->SetMuon(m_Muon->GetModel(), m_Poca);
        } else {
-           this->SetMuon(m_Muon);
+           this->SetMuon(*m_Muon);
        }
    }
 }
 
-vtkPolyData *vtkVoxRaytracerRepresentation::GetPolyData() const {
+vtkPolyData *VoxRaytracerRepresentation::GetPolyData() const {
   std::cout << "get Raytracer polydata\n";
   m_SelectedElement->Update();
   return m_SelectedElement->GetOutput();
 }
 
-void vtkVoxRaytracerRepresentation::SetRepresentationElements(
+void VoxRaytracerRepresentation::SetRepresentationElements(
-    vtkVoxRaytracerRepresentation::RepresentationElements el) {
+    VoxRaytracerRepresentation::RepresentationElements el) {
   switch (el) {
-  case Vtk::vtkVoxRaytracerRepresentation::RayElements:
+  case Vtk::VoxRaytracerRepresentation::RayElements:
     m_SelectedElement = m_RayLine;
     break;
-  case Vtk::vtkVoxRaytracerRepresentation::VoxelsElements:
+  case Vtk::VoxRaytracerRepresentation::VoxelsElements:
     m_SelectedElement = m_RayRepresentation;
     break;
   default:
@@ -111,8 +113,9 @@ void vtkVoxRaytracerRepresentation::SetRepresentationElements(
   }
 }
 
-void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
+void VoxRaytracerRepresentation::SetMuon(uLib::MuonScatter &muon) {
-  m_Muon = muon;
+  if (m_Muon) delete m_Muon;
+  m_Muon = new MuonScatter(muon);
   m_HasMuon = true;
   m_HasPoca = false;
 
@@ -173,8 +176,9 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
   this->SetRay(pt1, pt2);
 }
 
-void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca) {
+void VoxRaytracerRepresentation::SetMuon(uLib::MuonScatter &muon, HPoint3f poca) {
-  m_Muon = muon;
+  if (m_Muon) delete m_Muon;
+  m_Muon = new MuonScatter(muon);
   m_Poca = poca;
   m_HasMuon = true;
   m_HasPoca = true;
@@ -247,27 +251,27 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca) {
     this->SetRay(pt1, pt2);
 }
 
-void vtkVoxRaytracerRepresentation::SetMuon(vtkMuonScatter &muon) {
+void VoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
   HPoint3f poca = muon.GetPocaPoint();
-  MuonScatter &mu = muon.GetContent();
+  uLib::MuonScatter &mu = muon.GetModel();
   this->SetMuon(mu, poca);
 }
 
-VoxRaytracer::RayData vtkVoxRaytracerRepresentation::GetRay() { return m_Ray; }
+VoxRaytracer::RayData VoxRaytracerRepresentation::GetRay() { return m_Ray; }
 
-void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out) {
+void VoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out) {
   m_Ray = m_Content->TraceBetweenPoints(in, out);
   this->SetRay(&m_Ray);
 }
 
-void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f mid,
+void VoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f mid,
                                            HPoint3f out) {
   m_Ray = m_Content->TraceBetweenPoints(in, mid);
   m_Ray.AppendRay(m_Content->TraceBetweenPoints(mid, out));
   this->SetRay(&m_Ray);
 }
 
-void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray) {
+void VoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray) {
   vtkAppendPolyData *appender = m_RayRepresentation;
   appender->RemoveAllInputs();
 
@@ -286,15 +290,15 @@ void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray) {
   appender->Modified();
 }
 
-void vtkVoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba) {
+void VoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba) {
   this->SetColor(m_RayRepresentationActor, rgba);
 }
 
-void vtkVoxRaytracerRepresentation::SetRayColor(Vector4f rgba) {
+void VoxRaytracerRepresentation::SetRayColor(Vector4f rgba) {
   this->SetColor(m_RayLineActor, rgba);
 }
 
-void vtkVoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba) {
+void VoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba) {
   if (!actor)
     return;
   vtkProperty *pr = actor->GetProperty();
@@ -303,7 +307,7 @@ void vtkVoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba) {
   pr->SetDiffuse(1);
 }
 
-void vtkVoxRaytracerRepresentation::InstallPipe() {
+void VoxRaytracerRepresentation::InstallPipe() {
 
   vtkSmartPointer<vtkAppendPolyData> append =
       vtkSmartPointer<vtkAppendPolyData>::New();

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h

@@ -44,13 +44,13 @@
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 
-#include "Math/Dense.h"
+#include "Vtk/Math/vtkDense.h"
 
 #include "Vtk/uLibVtkInterface.h"
 
-#include "HEP/Detectors/MuonScatter.h"
+#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
 
-#include "Math/StructuredGrid.h"
+#include "Vtk/Math/vtkStructuredGrid.h"
 #include "Math/VoxRaytracer.h"
 
 class vtkActor;
@@ -58,12 +58,12 @@ class vtkActor;
 namespace uLib {
 namespace Vtk {
 
-class vtkVoxRaytracerRepresentation : public Puppet {
+class VoxRaytracerRepresentation : public Prop3D {
   typedef VoxRaytracer Content;
 
 public:
-  vtkVoxRaytracerRepresentation(Content &content);
+  VoxRaytracerRepresentation(Content &content);
-  ~vtkVoxRaytracerRepresentation();
+  ~VoxRaytracerRepresentation();
 
   uLib::VoxRaytracer *GetRaytracerAlgorithm();
 
@@ -76,13 +76,13 @@ public:
   enum RepresentationElements { RayElements, VoxelsElements };
   void SetRepresentationElements(enum RepresentationElements el);
 
-  void SetMuon(MuonScatter &muon);
+  void SetMuon(uLib::MuonScatter &muon);
 
-  void SetMuon(MuonScatter &muon, HPoint3f poca);
+  void SetMuon(uLib::MuonScatter &muon, HPoint3f poca);
 
-  void SetMuon(class vtkMuonEvent &muon);
+  void SetMuon(class MuonEvent &muon);
 
-  void SetMuon(class vtkMuonScatter &muon);
+  void SetMuon(class MuonScatter &muon);
 
   VoxRaytracer::RayData GetRay();
 
@@ -101,7 +101,7 @@ private:
   void SetColor(vtkActor *actor, Vector4f rgba);
 
   VoxRaytracer *m_Content;
-  MuonScatter m_Muon;
+  MuonScatter *m_Muon;
   HPoint3f m_Poca;
   bool m_HasMuon;
   bool m_HasPoca;

src/Vtk/Math/testing/vtkAssemblyTest.cpp

@@ -9,9 +9,9 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-#include "Math/Assembly.h"
+#include "Vtk/Math/vtkAssembly.h"
-#include "Math/ContainerBox.h"
+#include "Vtk/Math/vtkContainerBox.h"
-#include "Math/Cylinder.h"
+#include "Vtk/Math/vtkCylinder.h"
 #include "Vtk/Math/vtkAssembly.h"
 #include "Vtk/vtkObjectsContext.h"
 #include "Vtk/uLibVtkViewer.h"
@@ -28,40 +28,40 @@ using namespace uLib;
 int main(int argc, char **argv) {
     bool interactive = (argc > 1 && std::string(argv[1]) == "-i");
 
-    // ---- 1. Build model objects ----
+    // ---- 1. Build model objects on the heap (expected by uLib SmartPointer) ----
-    ContainerBox box1;
+    auto* box1 = new ContainerBox();
-    box1.Scale(Vector3f(1_m, 2_m, 0.5_m));
+    box1->Scale(Vector3f(1, 2, 0.5));
-    box1.SetPosition(Vector3f(0, 0, 0));
+    // box1->SetPosition(Vector3f(0, 0, 0));
 
-    ContainerBox box2;
+    auto* box2 = new ContainerBox();
-    box2.Scale(Vector3f(0.5_m, 0.5_m, 3_m));
+    box2->Scale(Vector3f(0.5, 0.5, 3));
-    box2.SetPosition(Vector3f(2_m, 0, 0));
+    box2->SetPosition(Vector3f(2, 0, 0));
 
-    Cylinder cyl(0.3_m, 1.5_m, 1);
+    auto* cyl = new Cylinder(1, 1.5, 1);
-    cyl.SetPosition(Vector3f(0, 3_m, 0));
+    cyl->SetPosition(Vector3f(0, 3, 0));
 
     // ---- 2. Create an Assembly and add objects ----
-    Assembly assembly;
+    auto* assembly = new 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 ----
-    assembly.SetPosition(Vector3f(1_m, 1_m, 0));
+    // assembly->SetPosition(Vector3f(1_m, 1_m, 0));
 
-    // ---- 5. Visualize (create puppets to set properties) ----
+    // ---- 5. Visualize (create prop3ds to set properties) ----
-    Vtk::Assembly vtkAsm(&assembly);
+    Vtk::Assembly vtkAsm(assembly); // Vtk::Assembly takes ownership of the model wrapper
 
     Vtk::Viewer viewer;
-    vtkAsm.AddToViewer(viewer); // This triggers puppet creation via ConnectRenderer which eventually calls Puppet::GetProp
+    vtkAsm.AddToViewer(viewer); 
     
-    // Explicitly update to ensure puppets exist and are added to assemblies
+    // Explicitly update to ensure prop3ds exist and are added to assemblies
     vtkAsm.Update();
 
-    // Use the child context to find child puppets and set colors
+    // Use the child context to find child prop3ds and set colors
     if (auto* childCtx = vtkAsm.GetChildrenContext()) {
-        auto setProps = [](Vtk::Puppet* p, float r, float g, float b) {
+        auto setProps = [](Vtk::Prop3D* p, float r, float g, float b) {
             if (!p) return;
             vtkPropCollection* props = p->GetProps();
             props->InitTraversal();
@@ -74,16 +74,16 @@ int main(int argc, char **argv) {
             }
         };
 
-        setProps(childCtx->GetPuppet(&box1), 1.0, 0.0, 0.0); // Red
+        setProps(childCtx->GetProp3D(box1), 1.0, 0.0, 0.0); // Red
-        setProps(childCtx->GetPuppet(&box2), 0.0, 1.0, 0.0); // Green
+        setProps(childCtx->GetProp3D(box2), 0.0, 1.0, 0.0); // Green
-        setProps(childCtx->GetPuppet(&cyl),  0.0, 0.0, 1.0); // Blue
+        setProps(childCtx->GetProp3D(cyl),  0.0, 0.0, 1.0); // Blue
     }
 
-    std::cout << "Puppets in viewport: " << viewer.getPuppets().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
+    std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
 
     // ---- 4. Query the bounding box for terminal output ----
     Vector3f bbMin, bbMax;
-    assembly.GetBoundingBox(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;

src/Vtk/Math/testing/vtkContainerBoxTest.cpp

@@ -25,7 +25,6 @@
 
 #include "Vtk/uLibVtkViewer.h"
 
-#include "Math/ContainerBox.h"
 #include "Math/Units.h"
 #include "Vtk/Math/vtkContainerBox.h"
 
@@ -36,21 +35,28 @@ using namespace uLib;
 int main() {
   BEGIN_TESTING(vtk ContainerBox Test);
 
-  ContainerBox box;
+  {
-  box.Scale(Vector3f(1_m,5_m,1_m));
+    ContainerBox* box = new ContainerBox();
-  box.SetPosition(Vector3f(0,1_m,0));
+    box->Scale(Vector3f(1_m, 2_m, 1_m));
-  Vtk::vtkContainerBox v_box(&box);
+    box->SetPosition(Vector3f(0, 0, 0));
-  v_box.SetRepresentation(Vtk::Puppet::Surface);
+
+    Vtk::ContainerBox v_box(box);
+    v_box.Update();
+
+    v_box.SetRepresentation(Vtk::Prop3D::Surface);
     v_box.SetOpacity(0.5);
     v_box.SetSelectable(true);
+  }
 
-  box.findOrAddSignal(&ContainerBox::Updated)->connect([&box](){
+  Vtk::ContainerBox v_box;
-    std::cout << "box updated: " << box.GetWorldPoint(HPoint3f(1,1,1)) << std::endl;
+  v_box.findOrAddSignal(&Object::Updated)->connect([&v_box]() {
+    std::cout << "box updated: "
+              << v_box.get()->GetWorldPoint(HPoint3f(1, 1, 1)) << std::endl;
   });
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer v_viewer;
-    v_viewer.AddPuppet(v_box);
+    v_viewer.AddProp3D(v_box);
     v_viewer.Start();
   }
 

src/Vtk/Math/testing/vtkContainerBoxTest2.cpp

@@ -6,7 +6,7 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/uLibVtkViewer.h"
-#include "Math/ContainerBox.h"
+#include "Vtk/Math/vtkContainerBox.h"
 #include "Math/Units.h"
 #include "Vtk/Math/vtkContainerBox.h"
 #include <iostream>
@@ -15,12 +15,12 @@ using namespace uLib;
 
 int main() {
     std::cout << "Creating ContainerBox..." << std::endl;
-    ContainerBox box(Vector3f(1.0, 1.0, 1.0)); // 1x1x1 unit box
+    ContainerBox* box = new ContainerBox(Vector3f(1.0, 1.0, 1.0)); // 1x1x1 unit box
-    box.SetInstanceName("MyTestBox");
+    box->SetInstanceName("MyTestBox");
 
     std::cout << "Creating VTK representation..." << std::endl;
-    Vtk::vtkContainerBox v_box(&box);
+    Vtk::ContainerBox v_box(box);
-    v_box.SetRepresentation(Vtk::Puppet::Wireframe);
+    v_box.SetRepresentation(Vtk::Prop3D::Wireframe);
     v_box.SetColor(1.0, 0.0, 0.0); // Red
 
     // // 1. Initial Visualization setup (handled by Viewer)
@@ -38,7 +38,7 @@ int main() {
 
     std::cout << "Starting viewer (close window to exit)..." << std::endl;
     Vtk::Viewer viewer;
-    viewer.AddPuppet(v_box);
+    viewer.AddProp3D(v_box);
     viewer.Start();
 
     return 0;

src/Vtk/Math/testing/vtkQuadMeshTest.cpp

@@ -24,7 +24,6 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/Math/vtkQuadMesh.h"
-#include "Math/QuadMesh.h"
 #include "Vtk/uLibVtkViewer.h"
 
 #define BOOST_TEST_MODULE VtkQuadMeshTest
@@ -42,7 +41,7 @@ BOOST_AUTO_TEST_CASE(vtkQuadMeshConstruction) {
 
   mesh.AddQuad(Vector4i(0, 1, 2, 3));
 
-  Vtk::vtkQuadMesh v_mesh(mesh);
+  Vtk::QuadMesh v_mesh(&mesh);
 
   Object::connect(&mesh, &QuadMesh::Updated, [&mesh]() {
     Vector3f points[4];
@@ -50,15 +49,15 @@ BOOST_AUTO_TEST_CASE(vtkQuadMeshConstruction) {
     points[1] = mesh.GetPoint(1);
     points[2] = mesh.GetPoint(2);
     points[3] = mesh.GetPoint(3);
-    std::cout << "mesh updated: " << points[0] << " " << points[1] 
+    std::cout << "mesh updated: " << points[0] << " " << points[1] << " "
-              << " " << points[2] << " " << points[3] << std::endl;
+              << points[2] << " " << points[3] << std::endl;
   });
 
   v_mesh.Update();
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
-    viewer.AddPuppet(v_mesh);
+    viewer.AddProp3D(v_mesh);
     viewer.Start();
   }
 

src/Vtk/Math/testing/vtkStructuredGridTest.cpp

@@ -24,7 +24,6 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/Math/vtkStructuredGrid.h"
-#include "Math/StructuredGrid.h"
 #include "Vtk/uLibVtkViewer.h"
 
 #define BOOST_TEST_MODULE VtkStructuredGridTest
@@ -36,11 +35,11 @@ BOOST_AUTO_TEST_CASE(vtkStructuredGridTest) {
   StructuredGrid grid(Vector3i(10, 10, 100));
   grid.SetSpacing(Vector3f(3, 1, 1));
 
-  Vtk::vtkStructuredGrid grid_viewer(grid);
+  Vtk::StructuredGrid grid_viewer(&grid);
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
-    viewer.AddPuppet(grid_viewer);
+    viewer.AddProp3D(grid_viewer);
     viewer.Start();
   }
 

src/Vtk/Math/testing/vtkTriangleMeshTest.cpp

@@ -24,7 +24,6 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/Math/vtkTriangleMesh.h"
-#include "Math/TriangleMesh.h"
 #include "Vtk/uLibVtkViewer.h"
 
 #define BOOST_TEST_MODULE VtkTriangleMeshTest
@@ -40,22 +39,23 @@ BOOST_AUTO_TEST_CASE(vtkTriangleMeshConstruction) {
   mesh.AddPoint(Vector3f(1, 0, 0));
   mesh.AddTriangle(Vector3i(0, 1, 2));
 
-  Vtk::vtkTriangleMesh v_mesh(mesh);
+  Vtk::TriangleMesh v_mesh(&mesh);
 
   Object::connect(&mesh, &TriangleMesh::Updated, [&mesh]() {
     Vector3f points[3];
     points[0] = mesh.GetPoint(0);
     points[1] = mesh.GetPoint(1);
     points[2] = mesh.GetPoint(2);
-    std::cout << "mesh updated: " << points[0].transpose() << " " << points[1].transpose() 
+    std::cout << "mesh updated: " << points[0].transpose() << " "
-              << " " << points[2].transpose() << std::endl;
+              << points[1].transpose() << " " << points[2].transpose()
+              << std::endl;
   });
 
   v_mesh.Update();
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
-    viewer.AddPuppet(v_mesh);
+    viewer.AddProp3D(v_mesh);
     viewer.Start();
   }
 
@@ -66,13 +66,13 @@ BOOST_AUTO_TEST_CASE(vtkTriangleMeshConstruction) {
 BOOST_AUTO_TEST_CASE(vtkTriangleMeshConstruction2) {
   TriangleMesh mesh;
 
-  Vtk::vtkTriangleMesh v_mesh(mesh);
+  Vtk::TriangleMesh v_mesh(&mesh);
   v_mesh.ReadFromStlFile("capelluzzo.stl");
   v_mesh.Update();
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
-    viewer.AddPuppet(v_mesh);
+    viewer.AddProp3D(v_mesh);
     viewer.Start();
   }
 

src/Vtk/Math/testing/vtkVoxImageInteractiveTest.cpp

@@ -10,48 +10,51 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/Math/vtkVoxImage.h"
-#include "Math/VoxImage.h"
 #include "Vtk/uLibVtkViewer.h"
-#include <vtkSmartPointer.h>
-#include <vtkCallbackCommand.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkProperty.h>
-#include <vtkRenderer.h>
-#include <vtkRenderWindow.h>
-#include <iostream>
 #include <cmath>
+#include <iostream>
+#include <vtkCallbackCommand.h>
+#include <vtkProperty.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+#include <vtkSmartPointer.h>
 
 using namespace uLib;
 
 struct AppState {
-    std::vector<Vtk::vtkVoxImage*> images;
+  std::vector<Vtk::VoxImage *> images;
-    Vtk::Viewer* viewer;
+  Vtk::Viewer *viewer;
 };
 
-void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void* clientData, void* callData) {
+void KeyPressCallbackFunction(vtkObject *caller, long unsigned int eventId,
-    auto* interactor = static_cast<vtkRenderWindowInteractor*>(caller);
+                              void *clientData, void *callData) {
-    auto* state = static_cast<AppState*>(clientData);
+  auto *interactor = static_cast<vtkRenderWindowInteractor *>(caller);
+  auto *state = static_cast<AppState *>(clientData);
 
   std::string key = interactor->GetKeySym();
   if (key == "w") {
     std::cout << "--> Switching all images to Wireframe Box" << std::endl;
-        for (auto* img : state->images) img->SetRepresentation(Vtk::Puppet::Wireframe);
+    for (auto *img : state->images)
+      img->SetRepresentation(Vtk::Prop3D::Wireframe);
     state->viewer->GetRenderWindow()->Render();
-    }
+  } else if (key == "s") {
-    else if (key == "s") {
+    std::cout << "--> Switching all images to Surface (Volume Rendering)"
-        std::cout << "--> Switching all images to Surface (Volume Rendering)" << std::endl;
+              << std::endl;
-        for (auto* img : state->images) img->SetRepresentation(Vtk::Puppet::Surface);
+    for (auto *img : state->images)
+      img->SetRepresentation(Vtk::Prop3D::Surface);
     state->viewer->GetRenderWindow()->Render();
-    }
+  } else if (key >= "0" && key <= "5") {
-    else if (key >= "0" && key <= "5") {
     int preset = key[0] - '0';
-        std::cout << "--> Switching all images to Rendering Preset " << preset << std::endl;
+    std::cout << "--> Switching all images to Rendering Preset " << preset
-        for (auto* img : state->images) img->setShadingPreset(preset);
+              << std::endl;
+    for (auto *img : state->images)
+      img->setShadingPreset(preset);
     state->viewer->GetRenderWindow()->Render();
   }
 }
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
   float factor = 1.0e6f;
 
   // --- Image 1: Spherical Shell ---
@@ -66,7 +69,7 @@ int main(int argc, char** argv) {
         float dx = x - 32.0f;
         float dy = y - 32.0f;
         float dz = z - 32.0f;
-                float dist = std::sqrt(dx*dx + dy*dy + dz*dz);
+        float dist = std::sqrt(dx * dx + dy * dy + dz * dz);
         Voxel v;
         if (dist < 25.0f && dist > 10.0f) {
           v.Value = (40.0f * (25.0f - dist) / 15.0f) / factor;
@@ -89,23 +92,25 @@ int main(int argc, char** argv) {
       for (int x = 0; x < dims2(0); ++x) {
         Voxel v;
         // Linear gradient along X, Y, Z
-                float val = (float(x)/dims2(0) + float(y)/dims2(1) + float(z)/dims2(2)) / 3.0f;
+        float val =
+            (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;
       }
     }
   }
 
-    Vtk::vtkVoxImage vtk_img1(img1);
+  Vtk::VoxImage vtk_img1(&img1);
   vtk_img1.setShadingPreset(0);
 
-    Vtk::vtkVoxImage vtk_img2(img2);
+  Vtk::VoxImage vtk_img2(&img2);
   vtk_img2.setShadingPreset(1); // Use Composite without MIP for variety
 
   Vtk::Viewer viewer;
   viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
-    viewer.AddPuppet(vtk_img1);
+  viewer.AddProp3D(vtk_img1);
-    viewer.AddPuppet(vtk_img2);
+  viewer.AddProp3D(vtk_img2);
 
   // Setup KeyPress Callback
   AppState state;
@@ -113,13 +118,14 @@ int main(int argc, char** argv) {
   state.images.push_back(&vtk_img2);
   state.viewer = &viewer;
 
-    vtkSmartPointer<vtkCallbackCommand> keyCallback = vtkSmartPointer<vtkCallbackCommand>::New();
+  vtkSmartPointer<vtkCallbackCommand> keyCallback =
+      vtkSmartPointer<vtkCallbackCommand>::New();
   keyCallback->SetCallback(KeyPressCallbackFunction);
   keyCallback->SetClientData(&state);
   viewer.GetInteractor()->AddObserver(vtkCommand::KeyPressEvent, keyCallback);
 
   std::cout << "=========================================" << std::endl;
-    std::cout << " vtkVoxImage Interactive Viewer Test" << std::endl;
+  std::cout << " VoxImage Interactive Viewer Test" << std::endl;
   std::cout << " [LEFT] Spherical Shell (MIP)" << std::endl;
   std::cout << " [RIGHT] Axes Gradient (Composite)" << std::endl;
   std::cout << "-----------------------------------------" << std::endl;

src/Vtk/Math/testing/vtkVoxImageTest.cpp

@@ -24,7 +24,6 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/Math/vtkVoxImage.h"
-#include "Math/VoxImage.h"
 #include "Vtk/uLibVtkViewer.h"
 
 #define BOOST_TEST_MODULE VtkVoxImageTest
@@ -46,12 +45,12 @@ BOOST_AUTO_TEST_CASE(vtkVoxImageConstruction) {
   img.InitVoxels(zero);
   img[Vector3i(3, 3, 3)] = nonzero;
 
-  Vtk::vtkVoxImage vtk_img(img);
+  Vtk::VoxImage vtk_img(&img);
   vtk_img.SaveToXMLFile("test_vtkvoximage.vti");
 
   if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
-    viewer.AddPuppet(vtk_img);
+    viewer.AddProp3D(vtk_img);
     viewer.Start();
   }
 

src/Vtk/Math/vtkAssembly.cpp

@@ -11,7 +11,7 @@
 
 #include "vtkAssembly.h"       // uLib::Vtk::Assembly
 #include "Vtk/vtkObjectsContext.h"
-#include "Math/vtkDense.h"
+#include "Vtk/Math/vtkDense.h"
 
 #include <vtkAssembly.h>       // VTK library ::vtkAssembly
 #include <vtkActor.h>
@@ -31,29 +31,27 @@ namespace Vtk {
 
 // ------------------------------------------------------------------ //
 Assembly::Assembly(uLib::Assembly *content)
-    : m_Content(content),
+    : ObjectWrapper(content),
       m_ChildContext(nullptr),
       m_BBoxActor(nullptr),
       m_VtkAsm(nullptr),
       m_InUpdate(false) {
     this->InstallPipe();
-    if (m_Content) {
+    if (this->m_model) {
-        Object::connect(m_Content, &uLib::Assembly::Updated,
+        Object::connect(this->m_model.get(), &uLib::Assembly::Updated,
                         this, &Assembly::Update);
     }
 }
 
 Assembly::~Assembly() {
     delete m_ChildContext;
-    if (m_BBoxActor)  m_BBoxActor->Delete();
-    if (m_VtkAsm)     m_VtkAsm->Delete();
 }
 
 // ------------------------------------------------------------------ //
 void Assembly::InstallPipe() {
-    // 1. Create the VTK library assembly that groups everything
+    // 1. Setup the internal VTK assembly
-    m_VtkAsm = ::vtkAssembly::New();
+    m_VtkAsm = vtkSmartPointer<::vtkAssembly>::New();
-    m_VtkAsm->PickableOff();
+    m_BBoxActor = vtkSmartPointer<::vtkActor>::New();
     this->SetProp(m_VtkAsm);
 
     // 2. Create the bounding-box wireframe actor
@@ -64,20 +62,19 @@ void Assembly::InstallPipe() {
     vtkNew<vtkPolyDataMapper> mapper;
     mapper->SetInputConnection(cube->GetOutputPort());
 
-    m_BBoxActor = vtkActor::New();
     m_BBoxActor->SetMapper(mapper);
     m_BBoxActor->GetProperty()->SetRepresentationToWireframe();
     m_BBoxActor->GetProperty()->SetColor(1.0, 0.85, 0.0);   // gold wireframe
     m_BBoxActor->GetProperty()->SetLineWidth(1.5);
     m_BBoxActor->GetProperty()->SetOpacity(0.6);
     m_BBoxActor->PickableOff();
-    m_BBoxActor->SetVisibility(m_Content ? m_Content->GetShowBoundingBox() : false);
+    m_BBoxActor->SetVisibility(this->m_model ? this->m_model->GetShowBoundingBox() : false);
 
     m_VtkAsm->AddPart(m_BBoxActor);
 
-    // 3. Build a child-objects context (auto-creates puppets for each child)
+    // 3. Build a child-objects context (auto-creates prop3ds for each child)
-    if (m_Content) {
+    if (this->m_model) {
-        m_ChildContext = new vtkObjectsContext(m_Content);
+        m_ChildContext = new ObjectsContext(this->m_model);
         // Link the children context's assembly into our group assembly
         if (auto* childProp = vtkProp3D::SafeDownCast(m_ChildContext->GetProp())) {
             m_VtkAsm->AddPart(childProp);
@@ -93,15 +90,8 @@ void Assembly::Update() {
     if (m_InUpdate) return;
     m_InUpdate = true;
     
-    if (m_Content && m_VtkAsm) {
+    // Delegate to Prop3D to handle standard transformation application (uses GetContent())
-        // Apply world matrix from the assembly content
+    this->Prop3D::Update();
-        vtkNew<vtkMatrix4x4> m;
-        Matrix4fToVtk(m_Content->GetMatrix(), m);
-        m_VtkAsm->SetUserMatrix(m);
-        m_VtkAsm->Modified();
-    }
-
-    this->Puppet::Update();
     this->UpdateBoundingBox();
     if (m_ChildContext)
         m_ChildContext->Update();
@@ -110,33 +100,37 @@ void Assembly::Update() {
 
 void Assembly::SyncFromVtk() {
     if (m_InUpdate) return;
-    if (!m_Content || !m_VtkAsm) return;
-
     m_InUpdate = true;
     
-    // VTK -> Model: Update world matrix (accounting for model parents)
+    // Sync the group-level transformation from VTK to the domain model
-    if (vtkProp3D* proxy = this->GetProxyProp()) {
+    this->Prop3D::SyncFromVtk();
-        m_Content->SetWorldMatrix(VtkToMatrix4f(proxy->GetUserMatrix()));
-        m_Content->FromMatrix(m_Content->GetMatrix());
-    }
     
-    this->UpdateBoundingBox();
+    // Propagate sync to children
     if (m_ChildContext)
         m_ChildContext->SyncFromVtk();
     
-    m_Content->Updated(); // Notify change in model
-
     m_InUpdate = false;
 }
 
+
+void Assembly::serialize_display(uLib::Archive::display_properties_archive &ar, const unsigned int version) {
+    // 1. Register base class appearance/transform
+    this->Prop3D::serialize_display(ar, version);
+
+    // 2. Map domain model properties (Bounding Box visibility, etc.)
+    if (this->m_model) {
+        ar & HRP("ShowBoundingBox", m_model->m_ShowBoundingBox);
+    }
+}
+
 // ------------------------------------------------------------------ //
 void Assembly::UpdateBoundingBox() {
-    if (!m_Content || !m_BBoxActor) return;
+    if (!this->m_model || !m_BBoxActor) return;
 
-    m_BBoxActor->SetVisibility(m_Content->GetShowBoundingBox());
+    m_BBoxActor->SetVisibility(this->m_model->GetShowBoundingBox());
 
     Vector3f bbMin, bbMax;
-    m_Content->GetBoundingBox(bbMin, bbMax);
+    this->m_model->GetBoundingBox(bbMin, bbMax);
 
     // Avoid degenerate boxes
     Vector3f size = bbMax - bbMin;
@@ -188,10 +182,6 @@ void Assembly::UpdateBoundingBox() {
     m_BBoxActor->Modified();
 }
 
-// ------------------------------------------------------------------ //
-vtkObjectsContext *Assembly::GetChildrenContext() const {
-    return m_ChildContext;
-}
 
 } // namespace Vtk
 } // namespace uLib

src/Vtk/Math/vtkAssembly.h

@@ -12,60 +12,64 @@
 #ifndef U_VTK_ASSEMBLY_H
 #define U_VTK_ASSEMBLY_H
 
+#include "Core/ObjectFactory.h"
 #include "Math/Assembly.h"
-#include "uLibVtkInterface.h"
+#include "Vtk/uLibVtkInterface.h"
 
-class vtkActor;
+#include <vtkSmartPointer.h>
-class vtkAssembly;  // VTK library forward declaration (must be before namespace)
+#include <vtkActor.h>
+#include <vtkAssembly.h>
 
 namespace uLib {
 namespace Vtk {
 
-class vtkObjectsContext; // forward
+class ObjectsContext; // forward
 
 /**
- * @brief VTK Puppet for visualizing uLib::Assembly.
+ * @brief VTK Prop3D for visualizing uLib::Assembly.
  *
  * Manages a VTK assembly (vtkAssembly from the VTK library) that groups
- * all child puppets and applies the Assembly's AffineTransform. It also
+ * all child prop3ds and applies the Assembly's AffineTransform. It also
  * renders an optional bounding box wireframe computed from the Assembly's AABB.
  *
  * @note This class is uLib::Vtk::Assembly. It internally uses
  *       the VTK library class vtkAssembly for grouping, but the two
  *       are distinct.
  */
-class Assembly : public Puppet {
+class Assembly : public Prop3D, public uLib::ObjectWrapper<uLib::Assembly> {
 public:
-    uLibTypeMacro(Assembly, Puppet)
+    uLibTypeMacro(Assembly, Prop3D)
 
-    Assembly(uLib::Assembly *content);
+    /**
+     * @brief Constructor.
+     * @param content Pointer to the domain assembly model.
+     */
+    explicit Assembly(uLib::Assembly *content);
     virtual ~Assembly();
 
     /** @brief Updates the VTK representation from the model (model→VTK). */
     virtual void Update() override;
 
-    /** @brief Synchronizes the model from the VTK representation (VTK→model). */
     virtual void SyncFromVtk() override;
 
-    virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
+    virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_model.get(); }
-    virtual uLib::ObjectsContext* GetChildren() override { return (uLib::ObjectsContext*)m_Content; }
+    virtual uLib::ObjectsContext* GetChildren() override { return (uLib::ObjectsContext*)m_model.get(); }
 
-    /**
+    /** @brief Returns the visualization context for children. */
-     * @brief Returns the puppet managing child objects.
+    uLib::Vtk::ObjectsContext* GetChildrenContext() const { return m_ChildContext; }
-     */
 
-    /** @brief Returns the puppet managing child objects. */
+    /** @brief Property serialization for Display Properties Panel. */
-    vtkObjectsContext *GetChildrenContext() const;
+    void serialize_display(Archive::display_properties_archive &ar, const unsigned int version = 0) override;
 
 private:
     void UpdateBoundingBox();
     void InstallPipe();
 
-    uLib::Assembly     *m_Content;
+    vtkSmartPointer<::vtkAssembly>    m_VtkAsm;
-    vtkObjectsContext  *m_ChildContext;
+    vtkSmartPointer<::vtkActor>       m_BBoxActor;
-    vtkActor           *m_BBoxActor;
+
-    ::vtkAssembly      *m_VtkAsm; // VTK library assembly — NOT this class
+    uLib::Vtk::ObjectsContext *m_ChildContext;
-    bool                m_InUpdate;    // re-entrancy guard
+    bool m_InUpdate;
 };
 
 } // namespace Vtk

src/Vtk/Math/vtkContainerBox.cpp

@@ -41,8 +41,7 @@
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 
-#include "Math/vtkDense.h"
+#include "Vtk/Math/vtkDense.h"
-
 
 namespace uLib {
 namespace Vtk {
@@ -51,91 +50,57 @@ struct ContainerBoxData {
   vtkSmartPointer<vtkActor> m_Cube;
   vtkSmartPointer<vtkActor> m_Axes;
   vtkSmartPointer<vtkAssembly> m_VtkAsm;
-  vtkSmartPointer<vtkMatrix4x4> m_Affine;
   uLib::Connection m_UpdateSignal;
 
-  ContainerBoxData() : m_Cube(vtkSmartPointer<vtkActor>::New()), 
+  ContainerBoxData()
+      : m_Cube(vtkSmartPointer<vtkActor>::New()),
         m_Axes(vtkSmartPointer<vtkActor>::New()),
-                       m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()),
+        m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()) {}
-                       m_Affine(vtkSmartPointer<vtkMatrix4x4>::New()) {}
   ~ContainerBoxData() {
+    m_UpdateSignal.disconnect();
   }
 };
 
-
+ContainerBox::ContainerBox(ContainerBox::Content *content)
-
+    : d(new ContainerBoxData()),
-
+      ObjectWrapper(content ? content : new Content()) {
-
-vtkContainerBox::vtkContainerBox(vtkContainerBox::Content *content)
-    : d(new ContainerBoxData()), m_Content(content) {
   this->InstallPipe();
-  d->m_UpdateSignal = Object::connect(m_Content, &uLib::Object::Updated, this, &vtkContainerBox::Update);
+  d->m_UpdateSignal = Object::connect(
+      this->m_model.get(), &uLib::Object::Updated, this, &ContainerBox::Update);
 }
 
-vtkContainerBox::~vtkContainerBox() {
+ContainerBox::~ContainerBox() { delete d; }
-  delete d;
-}
 
-vtkPolyData *vtkContainerBox::GetPolyData() const {
+vtkPolyData *ContainerBox::GetPolyData() const {
   // TODO
   return NULL;
 }
 
-
+void ContainerBox::Update() {
-void vtkContainerBox::Update() {
   RecursiveMutex::ScopedLock lock(this->m_UpdateMutex);
-  if (!m_Content) return;
+  if (!this->m_model)
+    return;
 
-  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
+  vtkProp3D *prop = vtkProp3D::SafeDownCast(this->GetProp());
-  if (root) {
+  if (prop) {
-      // Apply local full matrix (TRS * LocalBox) so that nested assemblies work correctly
+    // Apply the full volume matrix (TRS * m_LocalT)
-      Matrix4f fullLocal = m_Content->GetMatrix() * m_Content->GetLocalMatrix();
     vtkNew<vtkMatrix4x4> m;
-      Matrix4fToVtk(fullLocal, m);
+    Matrix4fToVtk(this->m_model->GetMatrix(), m);
-      root->SetUserMatrix(m);
+    prop->SetUserMatrix(m);
-      root->Modified();
+    prop->Modified();
   }
 
   // Delegate rest of update (appearance, render, etc)
   ConnectionBlock blocker(d->m_UpdateSignal);
-  this->Puppet::Update();
+  this->Prop3D::Update();
-}
-
-
-void vtkContainerBox::SyncFromVtk() {
-  RecursiveMutex::ScopedLock lock(this->m_UpdateMutex);
-  if (!m_Content) return;
-
-  vtkProp3D* root = this->GetProxyProp();
-  if (!root) return;
-
-  // VTK -> Model: Extract new world TRS from proxy, which matches the model's TRS center
-  vtkMatrix4x4* rootMat = root->GetUserMatrix();
-  // if (rootMat) {
-  //     std::cout << "[vtkContainerBox::SyncFromVtk] Read Proxy UserMatrix:" << std::endl;
-  //     rootMat->Print(std::cout);
-  // }
-  
-  Matrix4f vtkWorld = VtkToMatrix4f(rootMat);
-  
-  // Synchronize TRS property members from the updated local matrix
-  m_Content->FromMatrix(vtkWorld);
-
-  // std::cout << "[vtkContainerBox::SyncFromVtk] New Model WorldMatrix:" << std::endl << m_Content->GetWorldMatrix() << std::endl;
-
-  // Since we modified the model, notify observers, but block the loop back to VTK
-  // ConnectionBlock blocker(d->m_UpdateSignal);
-  m_Content->Updated();
 }
 
 
 
-
+void ContainerBox::InstallPipe() {
-
+  if (!this->m_model)
-void vtkContainerBox::InstallPipe() {
-  if (!m_Content)
     return;
-  Content *c = m_Content;
+  Content *c = this->m_model;
 
   // CUBE
   vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
@@ -171,11 +136,10 @@ void vtkContainerBox::InstallPipe() {
   d->m_VtkAsm->AddPart(d->m_Axes);
   this->SetProp(d->m_VtkAsm);
 
-  vtkProp3D* root = d->m_VtkAsm;
+  // vtkProp3D* root = d->m_VtkAsm;
-  if (root) {
+  // if (root) {
-      d->m_Affine = Matrix4fToVtk(m_Content->GetMatrix());
+  //     this->ApplyProp3DTransform(root);
-      root->SetUserMatrix(d->m_Affine);
+  // }
-  }
   this->Update();
 }
 

src/Vtk/Math/vtkContainerBox.h

@@ -26,6 +26,7 @@
 #ifndef U_VTKCONTAINERBOX_H
 #define U_VTKCONTAINERBOX_H
 
+#include "Core/ObjectFactory.h"
 #include "Math/ContainerBox.h"
 #include "uLibVtkInterface.h"
 #include "vtkPolydata.h"
@@ -37,14 +38,18 @@ namespace Vtk {
 
 struct ContainerBoxData;
 
-class vtkContainerBox : public Puppet, public Polydata {
+class ContainerBox : public Prop3D,
-  typedef ContainerBox Content;
+                     public Polydata,
+                     public uLib::ObjectWrapper<uLib::ContainerBox> {
+
+  uLibTypeMacro(ContainerBox, Prop3D,
+                Polydata) typedef uLib::ContainerBox Content;
 
 public:
-  vtkContainerBox(Content *content);
+  ContainerBox(Content *content = nullptr);
-  ~vtkContainerBox();
+  ~ContainerBox();
 
-  virtual class vtkPolyData *GetPolyData() const;
+  virtual class vtkPolyData *GetPolyData() const override;
 
   /**
    * @brief Updates the VTK representation from the internal state.
@@ -54,17 +59,18 @@ public:
   /**
    * @brief Synchronizes the model from the VTK representation (VTK→model).
    */
-  virtual void SyncFromVtk() override;
 
-  virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
+
+  virtual uLib::Object *GetContent() const override {
+    return (uLib::Object *)m_model.get();
+  }
 
 protected:
   virtual void InstallPipe();
 
   struct ContainerBoxData *d;
-  Content                 *m_Content;
-  bool                     m_BlockUpdate = false;
 
+  ULIB_DECLARE_PROPERTIES(ContainerBox)
 };
 
 } // namespace Vtk

src/Vtk/Math/vtkCylinder.cpp

@@ -32,31 +32,30 @@
 #include <vtkProperty.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
-#include "Math/vtkDense.h"
+#include "Vtk/Math/vtkDense.h"
 
 namespace uLib {
 namespace Vtk {
 
-vtkCylinder::vtkCylinder(vtkCylinder::Content *content)
+Cylinder::Cylinder(Cylinder::Content *content)
-    : m_Content(content), m_Actor(nullptr), m_VtkAsm(nullptr) {
+    : ObjectWrapper(content), m_Actor(nullptr), m_VtkAsm(nullptr) {
   this->InstallPipe();
-  m_UpdateSignal = Object::connect(m_Content, &uLib::Object::Updated, this, &vtkCylinder::Update);
+  m_UpdateSignal = Object::connect(this->m_model.get(), &uLib::Object::Updated, this, &Cylinder::Update);
 }
 
-vtkCylinder::~vtkCylinder() {
+Cylinder::~Cylinder() {
-  if (m_Actor) m_Actor->Delete();
+  m_UpdateSignal.disconnect();
-  if (m_VtkAsm) m_VtkAsm->Delete();
 }
 
-void vtkCylinder::Update() {
+void Cylinder::Update() {
-  if (!m_Content)
+  if (!this->m_model)
     return;
 
   vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
   if (root) {
       // 1. Placement handled specifically from content (use TRS GetMatrix, not World)
       vtkNew<vtkMatrix4x4> m;
-      Matrix4fToVtk(m_Content->GetMatrix(), m);
+      Matrix4fToVtk(this->m_model->GetMatrix(), m);
       root->SetUserMatrix(m);
 
       // 2. Shape-local properties (Radius, Height, Axis alignment) go to the internal actor
@@ -68,10 +67,10 @@ void vtkCylinder::Update() {
           
           // Initial source is centered Y-cylinder (Radial XZ [-1,1], Height Y [-0.5, 0.5])
           // Apply Radius and Height scaling
-          alignment->Scale(m_Content->GetRadius(), m_Content->GetHeight(), m_Content->GetRadius());
+          alignment->Scale(this->m_model->GetRadius(), this->m_model->GetHeight(), this->m_model->GetRadius());
 
           // Apply Axis alignment
-          int axis = m_Content->GetAxis();
+          int axis = this->m_model->GetAxis();
           if (axis == 0) alignment->RotateZ(-90);      // Y -> X
           else if (axis == 1) ;                        // Y -> Y (identity)
           else if (axis == 2) alignment->RotateX(90);  // Y -> Z
@@ -82,37 +81,16 @@ void vtkCylinder::Update() {
 
   // Delegate rest of update (appearance, render, etc)
   ConnectionBlock blocker(m_UpdateSignal);
-  this->Puppet::Update();
+  this->Prop3D::Update();
 }
 
-void vtkCylinder::SyncFromVtk() {
-  if (!m_Content) return;
 
-  vtkProp3D* root = this->GetProxyProp();
-  if (!root) return;
 
-  // VTK -> Model: Extract new world TRS from proxy
+void Cylinder::InstallPipe() {
-  vtkMatrix4x4* rootMat = root->GetUserMatrix();
+  if (!this->m_model)
-  if (rootMat) {
-      std::cout << "[vtkCylinder::SyncFromVtk] Read Proxy UserMatrix:" << std::endl;
-      rootMat->Print(std::cout);
-  }
-  
-  Matrix4f vtkWorld = VtkToMatrix4f(rootMat);
-  
-  // Directly sync model from the world matrix
-  m_Content->FromMatrix(vtkWorld);
-
-  std::cout << "[vtkCylinder::SyncFromVtk] New Model WorldMatrix:" << std::endl << m_Content->GetWorldMatrix() << std::endl;
-
-  m_Content->Updated(); 
-}
-
-void vtkCylinder::InstallPipe() {
-  if (!m_Content)
     return;
 
-  m_VtkAsm = ::vtkAssembly::New();
+  m_VtkAsm = vtkSmartPointer<::vtkAssembly>::New();
   this->SetProp(m_VtkAsm);
 
   vtkNew<vtkCylinderSource> cylinder;
@@ -120,7 +98,7 @@ void vtkCylinder::InstallPipe() {
   cylinder->SetHeight(1.0);
   cylinder->SetResolution(32);
 
-  m_Actor = vtkActor::New();
+  m_Actor = vtkSmartPointer<vtkActor>::New();
   vtkNew<vtkTransform> alignment;
   m_Actor->SetUserTransform(alignment);
 

src/Vtk/Math/vtkCylinder.h

@@ -26,9 +26,11 @@
 #ifndef U_VTKCYLINDER_H
 #define U_VTKCYLINDER_H
 
+#include "Core/ObjectFactory.h"
 #include "Math/Cylinder.h"
 #include "Vtk/uLibVtkInterface.h"
 #include <vtkActor.h>
+#include <vtkSmartPointer.h>
 class vtkAssembly;
 
 namespace uLib {
@@ -41,28 +43,29 @@ namespace Vtk {
  * mathematical state of a Cylinder object. It manages the alignment
  * between VTK's Y-centered cylinder and uLib's Z-based coordinate system.
  */
-class vtkCylinder : public Puppet {
+class Cylinder : public Prop3D, public uLib::ObjectWrapper<uLib::Cylinder> {
-  typedef Cylinder Content;
+  typedef uLib::Cylinder Content;
 
 public:
-  vtkCylinder(Content *content);
+  Cylinder(Content *content);
-  virtual ~vtkCylinder();
+  virtual ~Cylinder();
 
   /** Synchronizes the VTK actor with the uLib model matrix and vice-versa */
   virtual void Update() override;
 
   /** Synchronizes the uLib model matrix with the VTK actor specifically for gizmo interactions */
-  virtual void SyncFromVtk() override;
 
-  virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
+
+  virtual uLib::Object *GetContent() const override {
+    return (uLib::Object *)m_model.get();
+  }
 
 protected:
   /** Sets up the VTK visualization pipeline */
   virtual void InstallPipe();
 
-  vtkActor *m_Actor;
+  vtkSmartPointer<vtkActor> m_Actor;
-  ::vtkAssembly *m_VtkAsm;
+  vtkSmartPointer<::vtkAssembly> m_VtkAsm;
-  Content *m_Content;
   uLib::Connection m_UpdateSignal;
 };
 

src/Vtk/Math/vtkHLineRepresentation.h

@@ -31,10 +31,10 @@ class vtkPolyData;
 
 namespace uLib {
 
-class vtkHLineRepresentationDefault {
+class HLineRepresentationDefault {
 
 public:
-  vtkHLineRepresentationDefault();
+  HLineRepresentationDefault();
 };
 
 } // namespace uLib

src/Vtk/Math/vtkQuadMesh.cpp

@@ -42,14 +42,14 @@
 
 #include <vtkMatrix4x4.h>
 #include <vtkNew.h>
-#include "Math/vtkDense.h"
+#include "Vtk/Math/vtkDense.h"
 #include "Vtk/Math/vtkQuadMesh.h"
 #include <iostream>
 
 namespace uLib {
 namespace Vtk {
 
-void vtkQuadMesh::vtk2uLib_update() {
+void QuadMesh::vtk2uLib_update() {
   vtkIdType number_of_points = m_Poly->GetNumberOfPoints();
   vtkIdType number_of_quads = m_Poly->GetNumberOfPolys();
 
@@ -58,46 +58,46 @@ void vtkQuadMesh::vtk2uLib_update() {
             << "number of quads  = " << number_of_quads << "\n"
             << "//////\n";
 
-  m_content.Points().clear();
+  this->m_model->Points().clear();
   for (int i = 0; i < number_of_points; ++i) {
     double *point = m_Poly->GetPoint(i);
-    m_content.Points().push_back(Vector3f(point[0], point[1], point[2]));
+    this->m_model->Points().push_back(Vector3f(point[0], point[1], point[2]));
   }
 
-  m_content.Quads().resize(number_of_quads);
+  this->m_model->Quads().resize(number_of_quads);
   m_Poly->GetPolys()->InitTraversal();
   vtkSmartPointer<vtkIdList> idList = vtkSmartPointer<vtkIdList>::New();
   for (int i = 0; i < number_of_quads; ++i) {
     m_Poly->GetPolys()->GetNextCell(idList);
     if (idList->GetNumberOfIds() == 4) {
-      m_content.Quads()[i](0) = idList->GetId(0);
+      this->m_model->Quads()[i](0) = idList->GetId(0);
-      m_content.Quads()[i](1) = idList->GetId(1);
+      this->m_model->Quads()[i](1) = idList->GetId(1);
-      m_content.Quads()[i](2) = idList->GetId(2);
+      this->m_model->Quads()[i](2) = idList->GetId(2);
-      m_content.Quads()[i](3) = idList->GetId(3);
+      this->m_model->Quads()[i](3) = idList->GetId(3);
     }
   }
   m_Poly->Modified();
   m_Actor->GetMapper()->Update();
 }
 
-void vtkQuadMesh::uLib2vtk_update() {
+void QuadMesh::uLib2vtk_update() {
-  vtkIdType number_of_points = m_content.Points().size();
+  vtkIdType number_of_points = this->m_model->Points().size();
-  vtkIdType number_of_quads = m_content.Quads().size();
+  vtkIdType number_of_quads = this->m_model->Quads().size();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->SetNumberOfPoints(number_of_points);
   for (vtkIdType i = 0; i < number_of_points; i++) {
-    Vector3f p = m_content.Points().at(i);
+    Vector3f p = this->m_model->Points().at(i);
     points->SetPoint(i, p(0), p(1), p(2));
   }
 
   vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
   for (vtkIdType i = 0; i < number_of_quads; i++) {
     vtkIdType a, b, c, d;
-    a = m_content.Quads().at(i)(0);
+    a = this->m_model->Quads().at(i)(0);
-    b = m_content.Quads().at(i)(1);
+    b = this->m_model->Quads().at(i)(1);
-    c = m_content.Quads().at(i)(2);
+    c = this->m_model->Quads().at(i)(2);
-    d = m_content.Quads().at(i)(3);
+    d = this->m_model->Quads().at(i)(3);
     polys->InsertNextCell(4);
     polys->InsertCellPoint(a);
     polys->InsertCellPoint(b);
@@ -110,7 +110,7 @@ void vtkQuadMesh::uLib2vtk_update() {
   m_Poly->Modified();
 }
 
-void vtkQuadMesh::contentUpdate() {
+void QuadMesh::contentUpdate() {
   vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
   if (!vmat) {
     vtkNew<vtkMatrix4x4> mat;
@@ -118,50 +118,50 @@ void vtkQuadMesh::contentUpdate() {
     vmat = mat;
   }
 
-  Matrix4f transform = m_content.GetWorldMatrix();
+  Matrix4f transform = this->m_model->GetWorldMatrix();
   Matrix4fToVtk(transform, vmat);
 
   uLib2vtk_update();
 
   m_Poly->Modified();
   m_Actor->GetMapper()->Update();
-  Puppet::Update();
+  Prop3D::Update();
 }
 
-void vtkQuadMesh::Update() {
+void QuadMesh::Update() {
   vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
   if (!vmat) return;
 
   Matrix4f transform = VtkToMatrix4f(vmat);
-  m_content.SetMatrix(transform);
+  this->m_model->SetMatrix(transform);
-  m_content.Updated();
+  this->m_model->Updated();
 }
 
 // -------------------------------------------------------------------------- //
 
-vtkQuadMesh::vtkQuadMesh(vtkQuadMesh::Content &content)
+QuadMesh::QuadMesh(QuadMesh::Content *content)
-    : m_content(content), m_Poly(vtkPolyData::New()), m_Actor(vtkActor::New()) {
+    : ObjectWrapper(content), m_Poly(vtkPolyData::New()), m_Actor(vtkActor::New()) {
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
   mapper->SetInputData(m_Poly);
   m_Actor->SetMapper(mapper);
 
   vtkNew<vtkMatrix4x4> vmat;
-  Matrix4fToVtk(m_content.GetWorldMatrix(), vmat);
+  Matrix4fToVtk(this->m_model->GetWorldMatrix(), vmat);
   m_Actor->SetUserMatrix(vmat);
 
   this->SetProp(m_Actor);
-  Object::connect(&m_content, &Content::Updated, this, &vtkQuadMesh::contentUpdate);
+  Object::connect(this->m_model.get(), &Content::Updated, this, &QuadMesh::contentUpdate);
   this->contentUpdate();
 }
 
-vtkQuadMesh::~vtkQuadMesh() {
+QuadMesh::~QuadMesh() {
-  Object::disconnect(&m_content, &Content::Updated, this, &vtkQuadMesh::contentUpdate);
+  Object::disconnect(this->m_model.get(), &Content::Updated, this, &QuadMesh::contentUpdate);
   m_Poly->Delete();
   m_Actor->Delete();
 }
 
-void vtkQuadMesh::ReadFromFile(const char *filename) {
+void QuadMesh::ReadFromFile(const char *filename) {
   vtkSmartPointer<vtkPolyDataReader> reader =
       vtkSmartPointer<vtkPolyDataReader>::New();
   reader->SetFileName(filename);
@@ -170,7 +170,7 @@ void vtkQuadMesh::ReadFromFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void vtkQuadMesh::ReadFromXMLFile(const char *filename) {
+void QuadMesh::ReadFromXMLFile(const char *filename) {
   vtkSmartPointer<vtkXMLPolyDataReader> reader =
       vtkSmartPointer<vtkXMLPolyDataReader>::New();
   reader->SetFileName(filename);
@@ -179,7 +179,7 @@ void vtkQuadMesh::ReadFromXMLFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void vtkQuadMesh::ReadFromObjFile(const char *filename) {
+void QuadMesh::ReadFromObjFile(const char *filename) {
   vtkSmartPointer<vtkOBJReader> reader = vtkSmartPointer<vtkOBJReader>::New();
   reader->SetFileName(filename);
   reader->Update();
@@ -187,7 +187,7 @@ void vtkQuadMesh::ReadFromObjFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void vtkQuadMesh::ReadFromStlFile(const char *filename) {
+void QuadMesh::ReadFromStlFile(const char *filename) {
   vtkSmartPointer<vtkSTLReader> reader = vtkSmartPointer<vtkSTLReader>::New();
   reader->SetFileName(filename);
   reader->Update();
@@ -195,7 +195,7 @@ void vtkQuadMesh::ReadFromStlFile(const char *filename) {
   vtk2uLib_update();
 }
 
-vtkPolyData *vtkQuadMesh::GetPolyData() const { return m_Poly; }
+vtkPolyData *QuadMesh::GetPolyData() const { return m_Poly; }
 
 } // namespace Vtk
 } // namespace uLib

src/Vtk/Math/vtkQuadMesh.h

@@ -26,9 +26,10 @@
 #ifndef VTKQUADMESH_H
 #define VTKQUADMESH_H
 
+#include "Core/ObjectFactory.h"
 #include "Math/QuadMesh.h"
-#include "Vtk/uLibVtkInterface.h"
 #include "Vtk/Math/vtkPolydata.h"
+#include "Vtk/uLibVtkInterface.h"
 
 class vtkPolyData;
 class vtkActor;
@@ -36,12 +37,14 @@ class vtkActor;
 namespace uLib {
 namespace Vtk {
 
-class vtkQuadMesh : public Puppet, public Polydata {
+class QuadMesh : public Prop3D,
-  typedef QuadMesh Content;
+                 public Polydata,
+                 public uLib::ObjectWrapper<uLib::QuadMesh> {
+  typedef uLib::QuadMesh Content;
 
 public:
-  vtkQuadMesh(Content &content);
+  QuadMesh(Content *content);
-  ~vtkQuadMesh();
+  ~QuadMesh();
 
   void ReadFromFile(const char *filename);
 
@@ -51,17 +54,20 @@ public:
 
   void ReadFromStlFile(const char *filename);
 
-  virtual class vtkPolyData *GetPolyData() const;
+  vtkPolyData *GetPolyData() const override;
 
   virtual void contentUpdate();
 
-  virtual void Update();
+  void Update() override;
+  uLib::Object *GetContent() const override {
+    return (uLib::Object *)m_model.get();
+  }
 
 private:
   void vtk2uLib_update();
   void uLib2vtk_update();
 
-  QuadMesh &m_content;
+  // ObjectWrapper provides m_model
   vtkPolyData *m_Poly;
   vtkActor *m_Actor;
 };