refactor: replace HRP with NVP in Cylinder serialization and add stream operators for TRS

.agents/rules/micromamba.md

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

.clangd

@@ -1,7 +1,7 @@
 CompileFlags:
   CompilationDatabase: build
   Add: 
-    - -I/home/rigoni/devel/cmt/ulib/src
+    - -I/home/rigoni/devel/cmt/uLib/src
     - -isystem/home/share/micromamba/envs/mutom/include
     - -isystem/home/share/micromamba/envs/mutom/include/eigen3
     - -isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include
@@ -27,7 +27,7 @@ Diagnostics:
 
 ---
 If:
-  PathExclude: [/home/rigoni/devel/cmt/ulib/src/.*]
+  PathExclude: [/home/rigoni/devel/cmt/uLib/src/.*]
 Diagnostics:
   Suppress: ["*"]
 

.gitattributes

@@ -0,0 +1,2 @@
+*.vtk filter=lfs diff=lfs merge=lfs -text
+*.vti filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -13,3 +13,6 @@ src/Python/uLib/*.pyd
 src/Python/uLib/*.pyc
 src/Python/uLib/__pycache__
 src/Python/uLib/.nfs*
+test_props.xml
+test_props2.xml
+test_boost.cpp

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
     "clangd.fallbackFlags": [
-        "-I/home/rigoni/devel/cmt/ulib/src",
+        "-I/home/rigoni/devel/cmt/uLib/src",
         "-isystem/home/share/micromamba/envs/mutom/include",
         "-isystem/home/share/micromamba/envs/mutom/include/eigen3",
         "-isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include",
@@ -19,8 +19,7 @@
     "clangd.semanticHighlighting.enable": true,
     "clangd.arguments": [
         "--compile-commands-dir=build",
-        "--query-driver=/home/share/micromamba/envs/mutom/bin/g++,/home/share/micromamba/envs/mutom/bin/gcc,/home/share/micromamba/envs/mutom/bin/nvcc",
-        "--suppress-system-warnings",
+        "--query-driver=/home/share/micromamba/envs/mutom/bin/*",
         "--all-scopes-completion",
         "--completion-style=detailed",
         "--header-insertion=never",

CLAUDE.md

@@ -0,0 +1,90 @@
+
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+
+```bash
+# Activate the conda environment (required before any build/run)
+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
+
+# Configure (from repo root, using Conan preset)
+cmake --preset conan-release
+
+# Build everything
+cmake --build build -j$(nproc)
+
+# Build a specific target
+cmake --build build --target gcompose -j$(nproc)
+
+# Run tests
+cmake --build build --target test
+# or
+ctest --test-dir build
+
+# Run a single test binary (example)
+./build/src/Core/testing/CoreTest
+
+# Run the gcompose GUI app
+./build/app/gcompose/gcompose
+```
+
+First-time setup (if `build/` does not exist):
+```bash
+conan profile detect
+conan install . --output-folder=build --build=missing
+cmake --preset conan-release
+```
+
+## Architecture
+
+**uLib** is a C++ framework for Cosmic Muon Tomography (CMT), structured as layered shared libraries:
+
+```
+mutomCore  →  mutomMath  →  mutomDetectors  →  mutomGeant
+                                              ↘
+                                           mutomVtk  →  gcompose (Qt6 GUI app)
+                                           mutomRoot
+```
+
+### Core Object Model (`src/Core/`)
+- All framework objects inherit from `uLib::Object`
+- **Property system**: `Property<T>` wraps member pointers with change notification via `PropertyChanged` signal
+- **Signal/slot**: `uLib::Object::connect(sender, &Sender::Signal, callback)` — resembles Qt but works for non-QObject classes
+- **Serialization**: Boost archives (`xml_oarchive`, `text_oarchive`, `hrt_oarchive`); `hrp<T>` marks fields as "human-readable properties"
+- `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.
+- `Viewport`: base class managing the VTK renderer, picking, selection logic. Maintains `m_Puppets` vector and `m_ObjectToPuppet` map.
+- `QViewport` (inherits `QWidget` + `Viewport`): Qt-embedded VTK widget. Emits Qt signal `puppetSelected(Puppet*)` on click-selection via `OnSelectionChanged`.
+- `vtkObjectsContext`: wraps `ObjectsContext`, creating/destroying `Puppet`s as objects come/go. Emits `PuppetAdded`/`PuppetRemoved`.
+- 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.
+
+### 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).
+
+### Selection Sync Flow
+```
+Viewport click  →  Viewport::SelectPuppet()  →  QViewport::OnSelectionChanged()
+                →  emit puppetSelected(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: firstPane->setObject(puppet)  [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.
+- **Puppet ↔ Object map**: `Viewport::m_ObjectToPuppet` allows lookup by domain object; `vtkObjectsContext::GetPuppet(obj)` does the same.

CMake/uLibTargetMacros.cmake

@@ -84,6 +84,7 @@ macro(uLib_add_tests name)
     foreach(tn ${TESTS})
         add_executable(${tn} ${tn}.cpp)
         add_test(NAME ${tn} COMMAND ${tn})
+        set_tests_properties(${tn} PROPERTIES ENVIRONMENT "CTEST_PROJECT_NAME=uLib;QT_QPA_PLATFORM=offscreen")
 
         target_link_libraries(${tn} ${LIBRARIES})
 

CMakeLists.txt

@@ -21,7 +21,7 @@ endif()
 project(uLib)
 
 # CUDA Toolkit seems to be missing locally. Toggle ON if nvcc is made available.
-option(USE_CUDA "Enable CUDA support" ON)
+option(USE_CUDA "Enable CUDA support" OFF)
 if(USE_CUDA)
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -allow-unsupported-compiler")
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
@@ -38,7 +38,7 @@ endif()
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 6)
+set(PROJECT_VERSION_MINOR 7)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -103,6 +103,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
 
 # CTEST framework
+set(CTEST_PROJECT_NAME "uLib")
 include(CTest)
 enable_testing()
 
@@ -114,7 +115,7 @@ set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
 message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
 
-find_package(HDF5 REQUIRED CONFIG)
+find_package(HDF5 REQUIRED)
 
 find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
 include_directories(${Boost_INCLUDE_DIRS})
@@ -157,7 +158,10 @@ else()
                                 GUISupportQt)
 endif()
 
-find_package(Qt6 COMPONENTS Widgets REQUIRED)
+find_package(Qt6 COMPONENTS Widgets)
+if(Qt6_FOUND)
+    add_compile_definitions(HAVE_QT)
+endif()
 
 find_package(Geant4)
 if(Geant4_FOUND)

CMakePresets.json

@@ -11,6 +11,12 @@
                 "CMAKE_BUILD_TYPE": "Debug",
                 "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
             }
+        },
+        {
+            "name": "mutom",
+            "description": "",
+            "displayName": "",
+            "inherits": []
         }
     ]
 }

Testing/Temporary/CTestCostData.txt

@@ -0,0 +1 @@
+---

Testing/Temporary/LastTest.log

@@ -0,0 +1,3 @@
+Start testing: Mar 25 18:59 UTC
+----------------------------------------------------------
+End testing: Mar 25 18:59 UTC

app/gcompose/CMakeLists.txt

@@ -3,6 +3,20 @@ add_executable(gcompose
     src/main.cpp
     src/MainWindow.h
     src/MainWindow.cpp
+    src/ViewportPane.h
+    src/ViewportPane.cpp
+    src/MainPanel.h
+    src/MainPanel.cpp
+    src/ContextPanel.h
+    src/ContextPanel.cpp
+    src/ContextModel.h
+    src/ContextModel.cpp
+    src/StyleManager.h
+    src/StyleManager.cpp
+    src/PropertyWidgets.h
+    src/PropertyWidgets.cpp
+    src/PropertiesPanel.h
+    src/PropertiesPanel.cpp
 )
 
 set_target_properties(gcompose PROPERTIES
@@ -29,6 +43,7 @@ target_link_libraries(gcompose
     mutomMath
     mutomGeant
     mutomVtk
+    mutomRoot
     ${Geant4_LIBS_FILTERED}
     ${VTK_LIBRARIES}
     Qt6::Widgets

app/gcompose/src/ContextModel.cpp

@@ -0,0 +1,276 @@
+#include "ContextModel.h"
+#include <QString>
+#include <typeinfo>
+#include <cxxabi.h>
+#include <functional>
+#include "Core/Object.h"
+#include <QMimeData>
+#include <QDataStream>
+#include <QIODevice>
+#include <vector>
+#include <algorithm>
+
+ContextModel::ContextModel(QObject* parent) 
+    : QAbstractItemModel(parent), m_rootContext(nullptr) {}
+
+ContextModel::~ContextModel() {}
+
+void ContextModel::setContext(uLib::ObjectsContext* context) {
+    m_isReseting = true;
+    beginResetModel();
+    m_rootContext = context;
+    if (m_rootContext) {
+        auto refresh = [this]() {
+            if (this->m_isReseting) return;
+            this->m_isReseting = true;
+            this->beginResetModel();
+            this->endResetModel();
+            this->m_isReseting = false;
+        };
+
+        uLib::Object::connect(m_rootContext, &uLib::Object::Updated, refresh);
+        uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectAdded, [this, refresh](uLib::Object* obj) {
+            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+            refresh();
+        });
+        uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectRemoved, [this, refresh](uLib::Object* obj) {
+            refresh();
+        });
+
+        // Connect existing objects
+        for (auto* obj : m_rootContext->GetObjects()) {
+            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+        }
+    }
+    endResetModel();
+    m_isReseting = false;
+}
+
+QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent) const {
+    if (!hasIndex(row, column, parent) || !m_rootContext) {
+        return QModelIndex();
+    }
+
+    if (!parent.isValid()) {
+        if (row < m_rootContext->GetCount()) {
+            return createIndex(row, column, m_rootContext->GetObject(row));
+        }
+    } else {
+        uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+        uLib::ObjectsContext* parentCtx = parentObj->GetChildren();
+        if (parentCtx && row < (int)parentCtx->GetCount()) {
+            return createIndex(row, column, parentCtx->GetObject(row));
+        }
+    }
+    return QModelIndex();
+}
+
+QModelIndex ContextModel::parent(const QModelIndex& child) const {
+    if (!child.isValid() || !m_rootContext) {
+        return QModelIndex();
+    }
+
+    uLib::Object* childObj = static_cast<uLib::Object*>(child.internalPointer());
+    
+    // Finding the parent of childObj is O(N) since there is no parent pointer.
+    // We just do a recursive search starting from root context.
+    std::function<uLib::Object*(uLib::Object*, uLib::Object*)> findParent = 
+        [&findParent](uLib::Object* current, uLib::Object* target) -> uLib::Object* {
+        uLib::ObjectsContext* ctx = current->GetChildren();
+        if (ctx) {
+            for (const auto& obj : ctx->GetObjects()) {
+                if (obj == target) return current;
+                if (auto p = findParent(obj, target)) return p;
+            }
+        }
+        return nullptr;
+    };
+
+    uLib::Object* parentObj = findParent(m_rootContext, childObj);
+    if (!parentObj || parentObj == m_rootContext) {
+        return QModelIndex(); // Root items have invalid parent index
+    }
+
+    // Now need to find the row of parentObj in its own parent Context.
+    uLib::Object* grandParentObj = findParent(m_rootContext, parentObj);
+    uLib::ObjectsContext* grandParentCtx = grandParentObj ? grandParentObj->GetChildren() : m_rootContext;
+
+    int row = -1;
+    for (size_t i = 0; i < grandParentCtx->GetCount(); ++i) {
+        if (grandParentCtx->GetObject(i) == parentObj) {
+            row = (int)i;
+            break;
+        }
+    }
+
+    if (row != -1) {
+        return createIndex(row, 0, parentObj);
+    }
+    return QModelIndex();
+}
+
+int ContextModel::rowCount(const QModelIndex& parent) const {
+    if (!m_rootContext) return 0;
+
+    if (!parent.isValid()) {
+        return m_rootContext->GetCount();
+    }
+
+    uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+    if (auto parentCtx = parentObj->GetChildren()) {
+        return (int)parentCtx->GetCount();
+    }
+    return 0; // leaf node
+}
+
+int ContextModel::columnCount(const QModelIndex& parent) const {
+    return 1;
+}
+
+static QString getDemangledName(const std::type_info& info) {
+    int status = -4;
+    char* demangled = abi::__cxa_demangle(info.name(), nullptr, nullptr, &status);
+    QString res = (status == 0 && demangled) ? QString::fromUtf8(demangled) : QString::fromUtf8(info.name());
+    if (demangled) free(demangled);
+    
+    // Remove namespaces
+    int lastColon = res.lastIndexOf("::");
+    if (lastColon != -1) {
+        res = res.mid(lastColon + 2);
+    }
+    
+    // Remove "class " prefix if any
+    if (res.startsWith("class ")) res = res.mid(6);
+    return res;
+}
+
+QVariant ContextModel::data(const QModelIndex& index, int role) const {
+    if (!index.isValid()) return QVariant();
+
+    uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+    
+    if (role == Qt::DisplayRole) {
+        QString typeName = getDemangledName(typeid(*obj));
+        std::string instName = obj->GetInstanceName();
+        if (instName.empty()) return typeName;
+        return QString("%1 (%2)").arg(QString::fromStdString(instName)).arg(typeName);
+    }
+    
+    if (role == Qt::EditRole) {
+        return QString::fromStdString(obj->GetInstanceName());
+    }
+    
+    return QVariant();
+}
+
+QVariant ContextModel::headerData(int section, Qt::Orientation orientation, int role) const {
+    if (orientation == Qt::Horizontal && role == Qt::DisplayRole && section == 0) {
+        return "Object Context";
+    }
+    return QVariant();
+}
+
+Qt::ItemFlags ContextModel::flags(const QModelIndex& index) const {
+    if (!index.isValid()) return m_rootContext ? Qt::ItemIsDropEnabled : Qt::NoItemFlags;
+    
+    Qt::ItemFlags f = Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
+    uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+    if (dynamic_cast<uLib::ObjectsContext*>(obj)) {
+        f |= Qt::ItemIsDropEnabled;
+    }
+    return f;
+}
+
+Qt::DropActions ContextModel::supportedDropActions() const {
+    return Qt::MoveAction;
+}
+
+QStringList ContextModel::mimeTypes() const {
+    return {"application/x-ulib-object-ptr"};
+}
+
+QMimeData* ContextModel::mimeData(const QModelIndexList& indexes) const {
+    QMimeData* mimeData = new QMimeData();
+    QByteArray encodedData;
+    QDataStream stream(&encodedData, QIODevice::WriteOnly);
+    for (const auto& idx : indexes) {
+        if (idx.isValid() && idx.column() == 0) {
+            void* ptr = idx.internalPointer();
+            stream << reinterpret_cast<qlonglong>(ptr);
+        }
+    }
+    mimeData->setData("application/x-ulib-object-ptr", encodedData);
+    return mimeData;
+}
+
+bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) {
+    if (action != Qt::MoveAction || !data->hasFormat("application/x-ulib-object-ptr")) return false;
+
+    uLib::ObjectsContext* targetCtx = m_rootContext;
+    if (parent.isValid()) {
+        uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+        targetCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
+    }
+    if (!targetCtx) return false;
+
+    QByteArray encodedData = data->data("application/x-ulib-object-ptr");
+    QDataStream stream(&encodedData, QIODevice::ReadOnly);
+    std::vector<uLib::Object*> objectsToMove;
+    while (!stream.atEnd()) {
+        qlonglong ptrVal;
+        stream >> ptrVal;
+        objectsToMove.push_back(reinterpret_cast<uLib::Object*>(ptrVal));
+    }
+
+    if (objectsToMove.empty()) return false;
+
+    // Helper to find and remove from current parent
+    std::function<void(uLib::Object*, uLib::Object*)> findAndRemoveRecursive = 
+        [&findAndRemoveRecursive](uLib::Object* current, uLib::Object* target) {
+        if (auto ctx = current->GetChildren()) {
+            ctx->RemoveObject(target);
+            for (auto* obj : ctx->GetObjects()) {
+                findAndRemoveRecursive(obj, target);
+            }
+        }
+    };
+
+    m_isReseting = true;
+    beginResetModel();
+    for (auto* obj : objectsToMove) {
+        // Don't drop onto itself or its descendants
+        bool invalid = (obj == targetCtx || obj == (uLib::Object*)targetCtx);
+        if (!invalid) {
+             // check if targetCtx is descendant of obj
+             std::function<bool(uLib::Object*, uLib::Object*)> isDescendant = 
+                [&isDescendant](uLib::Object* root, uLib::Object* target) -> bool {
+                 if (auto ctx = root->GetChildren()) {
+                     for (auto* child : ctx->GetObjects()) {
+                         if (child == target) return true;
+                         if (isDescendant(child, target)) return true;
+                     }
+                 }
+                 return false;
+             };
+             if (isDescendant(obj, (uLib::Object*)targetCtx)) invalid = true;
+        }
+        
+        if (!invalid) {
+            findAndRemoveRecursive(m_rootContext, obj);
+            targetCtx->AddObject(obj);
+        }
+    }
+    endResetModel();
+    m_isReseting = false;
+    return true;
+}
+
+bool ContextModel::setData(const QModelIndex& index, const QVariant& value, int role) {
+    if (index.isValid() && role == Qt::EditRole) {
+        uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+        obj->SetInstanceName(value.toString().toStdString());
+        emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
+        return true;
+    }
+    return false;
+}

app/gcompose/src/ContextModel.h

@@ -0,0 +1,35 @@
+#ifndef CONTEXT_MODEL_H
+#define CONTEXT_MODEL_H
+
+#include <QAbstractItemModel>
+#include "Core/ObjectsContext.h"
+
+class ContextModel : public QAbstractItemModel {
+    Q_OBJECT
+public:
+    explicit ContextModel(QObject* parent = nullptr);
+    virtual ~ContextModel();
+
+    void setContext(uLib::ObjectsContext* context);
+
+    QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
+    QModelIndex parent(const QModelIndex& child) const override;
+    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+    Qt::ItemFlags flags(const QModelIndex& index) const override;
+    bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
+
+    // Drag and Drop support
+    Qt::DropActions supportedDropActions() const override;
+    QStringList mimeTypes() const override;
+    QMimeData* mimeData(const QModelIndexList& indexes) const override;
+    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
+
+private:
+    uLib::ObjectsContext* m_rootContext;
+    bool m_isReseting = false;
+};
+
+#endif // CONTEXT_MODEL_H

app/gcompose/src/ContextPanel.cpp

@@ -0,0 +1,122 @@
+#include "ContextPanel.h"
+#include "ContextModel.h"
+#include "PropertyWidgets.h"
+#include "PropertiesPanel.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QTreeView>
+#include <QSplitter>
+#include <QList>
+#include <QShortcut>
+#include <QItemSelectionModel>
+
+ContextPanel::ContextPanel(QWidget* parent) 
+    : QWidget(parent)
+    , m_context(nullptr) {
+    this->setObjectName("ContextPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 5, 0);
+
+    m_titleLabel = new QLabel("Context Panel", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+
+    m_layout->addWidget(m_titleBar);
+
+    m_treeView = new QTreeView(this);
+    m_treeView->setObjectName("ContextTree");
+    m_treeView->setHeaderHidden(false);
+    m_treeView->setDragEnabled(true);
+    m_treeView->setAcceptDrops(true);
+    m_treeView->setDropIndicatorShown(true);
+    m_treeView->setDragDropMode(QAbstractItemView::DragDrop);
+    
+    m_model = new ContextModel(this);
+    m_treeView->setModel(m_model);
+
+    m_splitter = new QSplitter(Qt::Vertical, this);
+    m_splitter->addWidget(m_treeView);
+    
+    m_propertiesPanel = new PropertiesPanel(m_splitter);
+    m_splitter->addWidget(m_propertiesPanel);
+
+    QList<int> sizes;
+    sizes << 400 << 600;
+    m_splitter->setSizes(sizes);
+
+    m_layout->addWidget(m_splitter);
+
+    connect(m_treeView->selectionModel(), &QItemSelectionModel::selectionChanged,
+            this, &ContextPanel::onSelectionChanged);
+
+    auto* deleteShortcut = new QShortcut(QKeySequence::Delete, this);
+    connect(deleteShortcut, &QShortcut::activated, [this]() {
+        auto selectedIndexes = m_treeView->selectionModel()->selectedIndexes();
+        if (selectedIndexes.isEmpty() || !m_context) return;
+        
+        std::vector<uLib::Object*> toRemove;
+        for (const auto& idx : selectedIndexes) {
+            if (idx.column() == 0) {
+                toRemove.push_back(static_cast<uLib::Object*>(idx.internalPointer()));
+            }
+        }
+        
+        for (auto* obj : toRemove) {
+            m_context->RemoveObject(obj);
+        }
+    });
+}
+
+ContextPanel::~ContextPanel() {}
+
+void ContextPanel::setContext(uLib::ObjectsContext* context) {
+    m_context = context;
+    m_model->setContext(context);
+    m_treeView->expandAll();
+}
+
+void ContextPanel::onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected) {
+    uLib::Object* target = nullptr;
+    if (!selected.indexes().isEmpty()) {
+        target = static_cast<uLib::Object*>(selected.indexes().first().internalPointer());
+    }
+
+    emit objectSelected(target);
+    m_propertiesPanel->setObject(target);
+}
+
+void ContextPanel::selectObject(uLib::Object* obj) {
+    if (!obj) {
+        clearSelection();
+        return;
+    }
+    
+    for (int i = 0; i < m_model->rowCount(); ++i) {
+        QModelIndex idx = m_model->index(i, 0);
+        if (idx.internalPointer() == obj) {
+            QSignalBlocker blocker(m_treeView->selectionModel());
+            m_treeView->selectionModel()->select(idx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
+            m_treeView->scrollTo(idx);
+            m_propertiesPanel->setObject(obj); // Explicitly update properties too
+            return;
+        }
+    }
+}
+
+void ContextPanel::clearSelection() {
+    QSignalBlocker blocker(m_treeView->selectionModel());
+    m_treeView->selectionModel()->clearSelection();
+    m_propertiesPanel->setObject(nullptr);
+}

app/gcompose/src/ContextPanel.h

@@ -0,0 +1,45 @@
+#ifndef CONTEXTPANEL_H
+#define CONTEXTPANEL_H
+
+#include <QWidget>
+#include <QItemSelection>
+#include "Core/Object.h"
+
+class QVBoxLayout;
+class QHBoxLayout;
+class QLabel;
+class QTreeView;
+class QSplitter;
+class ContextModel;
+namespace uLib { class ObjectsContext; }
+
+class ContextPanel : public QWidget {
+    Q_OBJECT
+public:
+    ContextPanel(QWidget* parent = nullptr);
+    ~ContextPanel();
+
+    void setContext(uLib::ObjectsContext* context);
+    void selectObject(uLib::Object* obj);
+    void clearSelection();
+
+signals:
+    void objectSelected(uLib::Object* obj);
+
+private slots:
+    void onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
+
+private:
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    
+    QTreeView* m_treeView;
+    ContextModel* m_model;
+    QSplitter* m_splitter;
+
+    class PropertiesPanel* m_propertiesPanel;
+    uLib::ObjectsContext* m_context;
+};
+
+#endif // CONTEXTPANEL_H

app/gcompose/src/MainPanel.cpp

@@ -0,0 +1,247 @@
+#include "MainPanel.h"
+#include "ViewportPane.h"
+#include "ContextPanel.h"
+#include "PropertiesPanel.h"
+#include "Core/ObjectFactory.h"
+#include "Core/ObjectsContext.h"
+#include "Vtk/vtkObjectsContext.h"
+#include "Vtk/vtkQViewport.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QSplitter>
+#include <QLabel>
+#include <QPushButton>
+#include <QMenu>
+#include <QAction>
+#include <QApplication>
+#include <QFileDialog>
+#include <QFileInfo>
+#include "StyleManager.h"
+#include "Math/VoxImage.h"
+
+MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr) {
+    this->setObjectName("MainPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    auto* mainLayout = new QVBoxLayout(this);
+    mainLayout->setContentsMargins(0, 0, 0, 0);
+    mainLayout->setSpacing(0);
+
+    // 1. Top Menu Panel
+    auto* menuPanel = new QWidget(this);
+    menuPanel->setObjectName("MenuPanel");
+    menuPanel->setFixedHeight(36);
+    
+    auto* menuLayout = new QHBoxLayout(menuPanel);
+    menuLayout->setContentsMargins(10, 0, 10, 0);
+    menuLayout->setSpacing(15);
+
+    auto* logo = new QLabel("G-COMPOSE", menuPanel);
+    logo->setObjectName("LogoLabel");
+
+    // File Menu Button
+    auto* btnFile = new QPushButton("File", menuPanel);
+    btnFile->setObjectName("MenuButton");
+    auto* fileMenu = new QMenu(btnFile);
+    fileMenu->addAction("Open", this, &MainPanel::onOpen);
+    fileMenu->addAction("Save", this, &MainPanel::onSave);
+    fileMenu->addAction("Save As", this, &MainPanel::onSaveAs);
+    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");
+    auto* newMenu = new QMenu(btnNew);
+    
+    auto classes = uLib::ObjectFactory::Instance().GetRegisteredClasses();
+    for (const auto& className : classes) {
+        auto* action = newMenu->addAction(QString::fromStdString(className));
+        connect(action, &QAction::triggered, [this, className]() {
+            this->onCreateObject(className);
+        });
+    }
+    btnNew->setMenu(newMenu);
+
+    menuLayout->addWidget(logo);
+    menuLayout->addWidget(btnFile);
+    menuLayout->addWidget(btnNew);
+    menuLayout->addWidget(btnTheme);
+    menuLayout->addStretch();
+
+    mainLayout->addWidget(menuPanel);
+
+    // 2. Central Splitter Area
+    m_rootSplitter = new QSplitter(Qt::Horizontal, this);
+    m_contextPanel = new ContextPanel(m_rootSplitter);
+    m_rootSplitter->addWidget(m_contextPanel);
+    m_rootSplitter->setStretchFactor(0, 0);
+
+    m_firstPane = new ViewportPane(m_rootSplitter);
+    m_rootSplitter->addWidget(m_firstPane);
+    m_rootSplitter->setStretchFactor(1, 1);
+    
+    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;
+            if (m_mainVtkContext) {
+                puppet = m_mainVtkContext->GetPuppet(obj);
+            }
+            viewport->SelectPuppet(puppet);
+            // Update the display properties in the viewport pane itself - use the puppet proxy if possible
+            m_firstPane->setObject(puppet ? (uLib::Object*)puppet : obj);
+        } else {
+            m_firstPane->setObject(obj);
+        }
+    });
+
+    // Set initial sizes: Context(250), Viewport(600), Properties(250)
+    QList<int> sizes;
+    sizes << 250 << 600 << 250;
+    m_rootSplitter->setSizes(sizes);
+
+    mainLayout->addWidget(m_rootSplitter, 1);
+}
+
+void MainPanel::setContext(uLib::ObjectsContext* context) {
+    m_context = context;
+    m_contextPanel->setContext(context);
+
+    if (m_mainVtkContext) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            viewport->RemovePuppet(*m_mainVtkContext);
+        }
+        delete m_mainVtkContext;
+        m_mainVtkContext = nullptr;
+    }
+
+    if (context) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            m_mainVtkContext = new uLib::Vtk::vtkObjectsContext(context);
+            // viewport->AddPuppet(*m_mainVtkContext); // redundant
+
+            auto syncSelection = [this](uLib::Vtk::Puppet* p) {
+                if (!p) {
+                    m_contextPanel->clearSelection();
+                    m_firstPane->setObject(nullptr);
+                } else {
+                    m_contextPanel->selectObject(p->GetContent());
+                    m_firstPane->setObject(p);
+                }
+            };
+            connect(viewport, &uLib::Vtk::QViewport::puppetSelected, syncSelection);
+
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetAdded, [this](uLib::Vtk::Puppet* 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->ZoomAuto();
+                            vp->Render();
+                        }
+                    }
+                }
+            });
+
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetRemoved, [this](uLib::Vtk::Puppet* 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->Render();
+                        }
+                    }
+                }
+            });
+
+            // Add any puppets 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)) {
+                    for (auto* pane : panes) {
+                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
+                            vp->AddPuppet(*p);
+                        }
+                    }
+                }
+            }
+
+            uLib::Object::connect(context, &uLib::Object::Updated, [viewport]() {
+                viewport->Render();
+            });
+            viewport->ZoomAuto();
+            viewport->Render();
+        }
+    }
+}
+
+void MainPanel::onCreateObject(const std::string& className) {
+    if (!m_context) return;
+    auto* obj = uLib::ObjectFactory::Instance().Create(className);
+    if (obj) {
+        m_context->AddObject(obj);
+    }
+}
+
+void MainPanel::onOpen() {
+    QString fileName = QFileDialog::getOpenFileName(this, "Open File", "", 
+        "VTK/VTI Images (*.vtk *.vti);;All Files (*.*)");
+    
+    if (fileName.isEmpty()) return;
+
+    QFileInfo info(fileName);
+    QString ext = info.suffix().toLower();
+
+    if (ext == "vti" || ext == "vtk") {
+        auto* obj = uLib::ObjectFactory::Instance().Create("VoxImage");
+        auto* vox = dynamic_cast<uLib::Abstract::VoxImage*>(obj);
+        if (vox) {
+            bool success = false;
+            if (ext == "vti") {
+                success = vox->ImportFromVti(fileName.toStdString().c_str());
+            } else {
+                success = vox->ImportFromVtk(fileName.toStdString().c_str());
+            }
+
+            if (success) {
+                obj->SetInstanceName(info.fileName().toStdString());
+                m_context->AddObject(obj);
+            } else {
+                delete obj;
+            }
+        } else {
+            delete obj;
+        }
+    }
+}
+
+void MainPanel::onSave() {
+    // Placeholder for save logic
+}
+
+void MainPanel::onSaveAs() {
+    // Placeholder for save as logic
+}
+
+void MainPanel::onExit() {
+    qApp->quit();
+}
+
+void MainPanel::onDarkTheme() {
+    StyleManager::applyStyle(qApp, "dark");
+}
+
+void MainPanel::onBrightTheme() {
+    StyleManager::applyStyle(qApp, "bright");
+}
+
+MainPanel::~MainPanel() {}

app/gcompose/src/MainPanel.h

@@ -0,0 +1,46 @@
+#ifndef MAINPANEL_H
+#define MAINPANEL_H
+
+#include <QWidget>
+
+class QSplitter;
+class ViewportPane;
+class ContextPanel;
+class PropertiesPanel;
+
+namespace uLib {
+    class ObjectsContext;
+    namespace Vtk {
+        class vtkObjectsContext;
+    }
+}
+
+class MainPanel : public QWidget {
+    Q_OBJECT
+public:
+    explicit MainPanel(QWidget* parent = nullptr);
+    virtual ~MainPanel();
+
+    void setContext(uLib::ObjectsContext* context);
+    ViewportPane* getFirstPane() const { return m_firstPane; }
+
+private slots:
+    void onOpen();
+    void onSave();
+    void onSaveAs();
+    void onExit();
+
+    void onDarkTheme();
+    void onBrightTheme();
+    
+    void onCreateObject(const std::string& className);
+
+private:
+    QSplitter* m_rootSplitter;
+    ViewportPane* m_firstPane;
+    ContextPanel* m_contextPanel;
+    uLib::ObjectsContext* m_context;
+    uLib::Vtk::vtkObjectsContext* m_mainVtkContext;
+};
+
+#endif // MAINPANEL_H

app/gcompose/src/MainWindow.cpp

@@ -1,11 +1,13 @@
 #include "MainWindow.h"
-#include <Vtk/vtkQViewport.h>
+#include <QSplitter>
+#include "MainPanel.h"
+#include "Core/ObjectsContext.h"
 
 using namespace uLib;
 
 MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
-    m_viewport = new Vtk::QViewport(this);
-    setCentralWidget(m_viewport);
+    m_panel = new MainPanel(this);
+    setCentralWidget(m_panel);
 
     setWindowTitle("gcompose - Qt VTK Interface");
     resize(1200, 800);
@@ -13,3 +15,7 @@ MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
 
 MainWindow::~MainWindow() {
 }
+
+void MainWindow::setContext(uLib::ObjectsContext* context) {
+    m_panel->setContext(context);
+}

app/gcompose/src/MainWindow.h

@@ -4,10 +4,13 @@
 #include <QMainWindow>
 #include <QVTKOpenGLNativeWidget.h>
 
+class MainPanel;
+class ViewportPane;
+
 namespace uLib {
 namespace Vtk {
-class QViewport;
 }
+class ObjectsContext;
 }
 
 class MainWindow : public QMainWindow {
@@ -16,10 +19,11 @@ public:
     MainWindow(QWidget* parent = nullptr);
     virtual ~MainWindow();
 
-    uLib::Vtk::QViewport* getViewport() { return m_viewport; }
+    void setContext(uLib::ObjectsContext* context);
+    MainPanel* getPanel() { return m_panel; }
 
 private:
-    uLib::Vtk::QViewport* m_viewport;
+    MainPanel* m_panel;
 };
 
 #endif

app/gcompose/src/PropertiesPanel.cpp

@@ -0,0 +1,46 @@
+#include "PropertiesPanel.h"
+#include "PropertyWidgets.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include "Core/Object.h"
+
+PropertiesPanel::PropertiesPanel(QWidget* parent) : QWidget(parent) {
+    this->setObjectName("PropertiesPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 5, 0);
+
+    m_titleLabel = new QLabel("Properties", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+
+    m_layout->addWidget(m_titleBar);
+
+    // Editor
+    m_editor = new uLib::Qt::PropertyEditor(this);
+    m_layout->addWidget(m_editor, 1);
+}
+
+void PropertiesPanel::setObject(uLib::Object* obj) {
+    if (obj) {
+        m_titleLabel->setText(QString("Properties: %1 (%2)")
+            .arg(QString::fromStdString(obj->GetInstanceName()))
+            .arg(obj->GetClassName()));
+    } else {
+        m_titleLabel->setText("Properties: (No selection)");
+    }
+    m_editor->setObject(obj);
+}
+
+PropertiesPanel::~PropertiesPanel() {}

app/gcompose/src/PropertiesPanel.h

@@ -0,0 +1,35 @@
+#ifndef PROPERTIES_PANEL_H
+#define PROPERTIES_PANEL_H
+
+#include <QWidget>
+
+namespace uLib {
+    class Object;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QVBoxLayout;
+class QLabel;
+
+/**
+ * @class PropertiesPanel
+ * @brief A panel dedicated to inspecting and editing properties of a selected uLib::Object.
+ */
+class PropertiesPanel : public QWidget {
+    Q_OBJECT
+public:
+    explicit PropertiesPanel(QWidget* parent = nullptr);
+    virtual ~PropertiesPanel();
+
+    /** @brief Sets the object to be inspected. */
+    void setObject(uLib::Object* obj);
+
+private:
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    
+    uLib::Qt::PropertyEditor* m_editor;
+};
+
+#endif // PROPERTIES_PANEL_H

app/gcompose/src/PropertyWidgets.cpp

@@ -0,0 +1,485 @@
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+#include <QRegularExpression>
+#include <QRegularExpressionMatch>
+#include <QComboBox>
+#include <QCheckBox>
+#include "Vtk/uLibVtkInterface.h"
+#include "Math/Units.h"
+#include "Math/Dense.h"
+#include <QPushButton>
+#include <QColorDialog>
+#include <QFrame>
+#include <QSlider>
+#include "Settings.h"
+
+namespace uLib {
+namespace Qt {
+
+PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent) 
+    : QWidget(parent), m_BaseProperty(prop) {
+    m_Layout = new QHBoxLayout(this);
+    m_Layout->setContentsMargins(4, 2, 4, 2);
+    
+    std::string unit = prop->GetUnits();
+    QString labelText = QString::fromStdString(prop->GetName());
+    if (!unit.empty() && unit != "color") {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        if (!pref.empty()) {
+            labelText += " [" + QString::fromStdString(pref) + "]";
+        } else {
+            labelText += " [" + QString::fromStdString(unit) + "]";
+        }
+    }
+    
+    m_Label = new QLabel(labelText, this);
+    m_Label->setMinimumWidth(120);
+    m_Layout->addWidget(m_Label);
+
+    this->setEnabled(!prop->IsReadOnly());
+}
+PropertyWidgetBase::~PropertyWidgetBase() {
+    m_Connection.disconnect();
+}
+
+// Helper for unit parsing
+double parseWithUnits(const QString& text, double* factorOut, QString* suffixOut) {
+    static QRegularExpression re("^\\s*([-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?)\\s*(_?[a-zA-Z]+)?\\s*$");
+    QRegularExpressionMatch match = re.match(text);
+    if (!match.hasMatch()) return 0.0;
+
+    double num = match.captured(1).toDouble();
+    QString unit = match.captured(3);
+    double factor = factorOut ? *factorOut : 1.0;
+
+    if (!unit.isEmpty()) {
+        QString u = unit.startsWith('_') ? unit.mid(1) : unit;
+        if (u == "m") factor = CLHEP::meter;
+        else if (u == "cm") factor = CLHEP::centimeter;
+        else if (u == "mm") factor = CLHEP::millimeter;
+        else if (u == "um") factor = CLHEP::micrometer;
+        else if (u == "nm") factor = CLHEP::nanometer;
+        else if (u == "km") factor = CLHEP::kilometer;
+        else if (u == "deg") factor = CLHEP::degree;
+        else if (u == "rad") factor = CLHEP::radian;
+        else if (u == "ns") factor = CLHEP::nanosecond;
+        else if (u == "s") factor = CLHEP::second;
+        else if (u == "ms") factor = CLHEP::millisecond;
+        else if (u == "MeV") factor = CLHEP::megaelectronvolt;
+        else if (u == "eV") factor = CLHEP::electronvolt;
+        else if (u == "keV") factor = CLHEP::kiloelectronvolt;
+        else if (u == "GeV") factor = CLHEP::gigaelectronvolt;
+        else if (u == "TeV") factor = CLHEP::teraelectronvolt;
+        if (suffixOut) *suffixOut = u;
+    } else if (suffixOut) {
+        // Reuse previous suffix if none provided, or empty
+    }
+
+    if (factorOut) *factorOut = factor;
+    return num * factor;
+}
+
+// UnitLineEdit implementation
+UnitLineEdit::UnitLineEdit(QWidget* parent) : QLineEdit(parent), m_Value(0), m_Factor(1.0), m_Suffix(""), m_IsInteger(false) {
+    connect(this, &QLineEdit::editingFinished, this, &UnitLineEdit::onEditingFinished);
+}
+
+void UnitLineEdit::setUnits(const QString& suffix, double factor) {
+    m_Suffix = suffix;
+    m_Factor = factor;
+    updateText();
+}
+
+void UnitLineEdit::setValue(double val) {
+    if (m_Value != val) {
+        m_Value = val;
+        // Suffix heuristic ONLY if it was mm and no explicit unit was given?
+        // Actually, if m_Suffix is empty or we have a specific one, we should respect it.
+        // The original code had a heuristic, but it's better to let property decide.
+        // Let's keep it ONLY if m_Suffix was mm (legacy behavior)
+        if (!m_IsInteger && m_Suffix == "mm" && std::abs(val) >= 1000.0) { m_Suffix = "m"; m_Factor = CLHEP::meter; }
+        updateText();
+    }
+}
+
+void UnitLineEdit::onEditingFinished() {
+    double factor = m_Factor;
+    QString suffix = m_Suffix;
+    double parsedVal = parseWithUnits(text(), &factor, &suffix);
+    if (m_IsInteger) {
+        parsedVal = std::round(parsedVal);
+    }
+    
+    if (m_Value != parsedVal) {
+        m_Value = parsedVal;
+        emit valueManualChanged(m_Value);
+    }
+    updateText();
+}
+
+void UnitLineEdit::updateText() {
+    QSignalBlocker blocker(this);
+    QString s;
+    if (m_IsInteger) {
+        s = QString::number((int)m_Value);
+        if (s.isEmpty()) s = "0";
+    } else {
+        double displayVal = m_Value / m_Factor;
+        s = QString::number(displayVal, 'g', 6);
+        if (!s.contains('.') && !s.contains('e')) {
+            s += ".0";
+        }
+    }
+    setText(s);
+}
+
+void UnitLineEdit::setIntegerOnly(bool integerOnly) {
+    m_IsInteger = integerOnly;
+    updateText();
+}
+
+DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    m_Edit->setValue(prop->Get());
+    m_Layout->addWidget(m_Edit, 1);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
+        m_Edit->setValue(m_Prop->Get());
+    });
+}
+
+FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    m_Edit->setValue(prop->Get());
+    m_Layout->addWidget(m_Edit, 1);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((float)val); });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<float>::Updated, [this](){
+        m_Edit->setValue((double)m_Prop->Get());
+    });
+}
+
+IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    m_Edit->setIntegerOnly(true);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    m_Edit->setValue(prop->Get());
+    m_Layout->addWidget(m_Edit, 1);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((int)val); });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<int>::Updated, [this](){
+        m_Edit->setValue((double)m_Prop->Get());
+    });
+}
+
+BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_CheckBox = new QCheckBox(this);
+    m_CheckBox->setChecked(prop->Get());
+    m_Layout->addWidget(m_CheckBox, 1);
+    connect(m_CheckBox, &QCheckBox::toggled, [this](bool val){ if (m_Prop->Get() != val) m_Prop->Set(val); });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::Updated, [this](){
+        if (m_CheckBox->isChecked() != m_Prop->Get()) {
+            QSignalBlocker blocker(m_CheckBox);
+            m_CheckBox->setChecked(m_Prop->Get());
+        }
+    });
+}
+BoolPropertyWidget::~BoolPropertyWidget() {}
+
+RangePropertyWidget::RangePropertyWidget(Property<double>* prop, QWidget* parent) 
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Slider = new QSlider(::Qt::Horizontal, this);
+    m_Slider->setRange(0, 100);
+    m_Slider->setMinimumWidth(80);
+    
+    m_Edit = new UnitLineEdit(this);
+    m_Edit->setFixedWidth(50);
+    
+    m_Layout->addWidget(m_Slider, 1);
+    m_Layout->addWidget(m_Edit, 0);
+
+    connect(m_Slider, &QSlider::valueChanged, this, &RangePropertyWidget::onSliderChanged);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
+    
+    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
+        this->updateUi();
+    });
+    updateUi();
+}
+RangePropertyWidget::~RangePropertyWidget() { m_Connection.disconnect(); }
+
+void RangePropertyWidget::updateUi() {
+    double val = m_Prop->Get();
+    m_Edit->setValue(val);
+    if (m_Prop->GetMax() != m_Prop->GetMin()) {
+        int sliderVal = (int)((val - m_Prop->GetMin()) / (m_Prop->GetMax() - m_Prop->GetMin()) * 100.0);
+        QSignalBlocker blocker(m_Slider);
+        m_Slider->setValue(sliderVal);
+    }
+}
+
+void RangePropertyWidget::onSliderChanged(int val) {
+    double realVal = m_Prop->GetMin() + (val / 100.0) * (m_Prop->GetMax() - m_Prop->GetMin());
+    m_Prop->Set(realVal);
+}
+
+ColorPropertyWidget::ColorPropertyWidget(Property<Vector3d>* prop, QWidget* parent) 
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Button = new QPushButton(this);
+    m_Button->setFixedWidth(60);
+    this->updateButtonColor();
+    m_Layout->addWidget(m_Button, 0, ::Qt::AlignRight);
+    
+    connect(m_Button, &QPushButton::clicked, this, &ColorPropertyWidget::onClicked);
+    m_Connection = uLib::Object::connect(m_Prop, &Property<Vector3d>::Updated, [this](){
+        this->updateButtonColor();
+    });
+}
+ColorPropertyWidget::~ColorPropertyWidget() {}
+
+void ColorPropertyWidget::updateButtonColor() {
+    Vector3d c = m_Prop->Get();
+    QColor color = QColor::fromRgbF(std::max(0.0, std::min(1.0, c.x())), 
+                                    std::max(0.0, std::min(1.0, c.y())), 
+                                    std::max(0.0, std::min(1.0, c.z())));
+    m_Button->setStyleSheet(QString("background-color: %1; border: 1px solid #555; height: 18px;").arg(color.name()));
+}
+
+void ColorPropertyWidget::onClicked() {
+    Vector3d c = m_Prop->Get();
+    QColor current = QColor::fromRgbF(std::max(0.0, std::min(1.0, c.x())), 
+                                      std::max(0.0, std::min(1.0, c.y())), 
+                                      std::max(0.0, std::min(1.0, c.z())));
+    QColor selected = QColorDialog::getColor(current, this, "Select Color");
+    if (selected.isValid()) {
+        m_Prop->Set(Vector3d(selected.redF(), selected.greenF(), selected.blueF()));
+    }
+}
+
+StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_LineEdit = new QLineEdit(this);
+    m_LineEdit->setText(QString::fromStdString(prop->Get()));
+    m_Layout->addWidget(m_LineEdit, 1);
+    connect(m_LineEdit, &QLineEdit::editingFinished, [this](){
+        std::string val = m_LineEdit->text().toStdString();
+        if (m_Prop->Get() != val) m_Prop->Set(val);
+    });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::Updated, [this](){
+        if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
+            QSignalBlocker blocker(m_LineEdit);
+            m_LineEdit->setText(QString::fromStdString(m_Prop->Get()));
+        }
+    });
+}
+StringPropertyWidget::~StringPropertyWidget() {}
+
+class GroupHeaderWidget : public QWidget {
+public:
+    GroupHeaderWidget(const QString& name, QWidget* parent = nullptr) : QWidget(parent) {
+        auto* layout = new QVBoxLayout(this);
+        layout->setContentsMargins(0, 8, 0, 4);
+        auto* line = new QFrame(this);
+        line->setFrameShape(QFrame::HLine);
+        line->setFrameShadow(QFrame::Sunken);
+        line->setStyleSheet("color: #555;");
+        layout->addWidget(line);
+        auto* label = new QLabel(name, this);
+        QFont font = label->font();
+        font.setBold(true);
+        font.setPointSize(font.pointSize() + 1);
+        label->setFont(font);
+        label->setStyleSheet("color: #aaa; text-transform: uppercase;");
+        layout->addWidget(label);
+    }
+};
+
+class EnumPropertyWidget : public PropertyWidgetBase {
+    PropertyBase* m_Prop;
+    QComboBox* m_Combo;
+public:
+    EnumPropertyWidget(PropertyBase* prop, QWidget* parent)
+        : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+        m_Combo = new QComboBox(this);
+        const auto& labels = prop->GetEnumLabels();
+        for (const auto& label : labels) {
+            m_Combo->addItem(QString::fromStdString(label));
+        }
+
+        // Get initial value
+        if (auto* p = dynamic_cast<Property<int>*>(prop)) {
+            m_Combo->setCurrentIndex(p->Get());
+            connect(m_Combo, &QComboBox::currentIndexChanged, [p](int index){
+                p->Set(index);
+            });
+            // Store connection in base m_Connection so it's auto-disconnected on destruction.
+            m_Connection = uLib::Object::connect(p, &Property<int>::Updated, [this, p](){
+                if (m_Combo->currentIndex() != p->Get()) {
+                    QSignalBlocker blocker(m_Combo);
+                    m_Combo->setCurrentIndex(p->Get());
+                }
+            });
+        }
+
+        m_Layout->addWidget(m_Combo, 1);
+    }
+};
+
+PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr) {
+    m_MainLayout = new QVBoxLayout(this);
+    m_MainLayout->setContentsMargins(0, 0, 0, 0);
+    m_ScrollArea = new QScrollArea(this);
+    m_ScrollArea->setWidgetResizable(true);
+    m_MainLayout->addWidget(m_ScrollArea);
+    m_Container = new QWidget();
+    m_ContainerLayout = new QVBoxLayout(m_Container);
+    m_ContainerLayout->setAlignment(::Qt::AlignTop);
+    m_ScrollArea->setWidget(m_Container);
+    
+    registerFactory<double>([](PropertyBase* p, QWidget* parent){
+        return new DoublePropertyWidget(static_cast<Property<double>*>(p), parent);
+    });
+    registerFactory<float>([](PropertyBase* p, QWidget* parent){
+        return new FloatPropertyWidget(static_cast<Property<float>*>(p), parent);
+    });
+    registerFactory<int>([](PropertyBase* p, QWidget* parent){
+        return new IntPropertyWidget(static_cast<Property<int>*>(p), parent);
+    });
+    registerFactory<bool>([](PropertyBase* p, QWidget* parent){
+        return new BoolPropertyWidget(static_cast<Property<bool>*>(p), parent);
+    });
+    registerFactory<std::string>([](PropertyBase* p, QWidget* parent){
+        return new StringPropertyWidget(static_cast<Property<std::string>*>(p), parent);
+    });
+    
+    // Register EnumProperty specifically (needs to check type since it holds Property<int> but is EnumProperty)
+    m_Factories[std::type_index(typeid(EnumProperty))] = [](PropertyBase* p, QWidget* parent) {
+        return new EnumPropertyWidget(p, parent);
+    };
+
+    // Vector Registration
+    registerFactory<Vector2i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2i, 2>(static_cast<Property<Vector2i>*>(p), parent); });
+    registerFactory<Vector2f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2f, 2>(static_cast<Property<Vector2f>*>(p), parent); });
+    registerFactory<Vector2d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2d, 2>(static_cast<Property<Vector2d>*>(p), parent); });
+    registerFactory<Vector3i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3i, 3>(static_cast<Property<Vector3i>*>(p), parent); });
+    registerFactory<Vector3f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3f, 3>(static_cast<Property<Vector3f>*>(p), parent); });
+    registerFactory<Vector3d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3d, 3>(static_cast<Property<Vector3d>*>(p), parent); });
+    registerFactory<Vector4i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4i, 4>(static_cast<Property<Vector4i>*>(p), parent); });
+    registerFactory<Vector4f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4f, 4>(static_cast<Property<Vector4f>*>(p), parent); });
+    registerFactory<Vector4d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4d, 4>(static_cast<Property<Vector4d>*>(p), parent); });
+}
+
+PropertyEditor::~PropertyEditor() {}
+
+void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
+    m_Object = obj;
+    clear();
+    if (!obj) return;
+    
+    // Choose which properties to show
+    const std::vector<::uLib::PropertyBase*>* props = &obj->GetProperties();
+    
+    if (displayOnly) {
+        if (auto* puppet = dynamic_cast<::uLib::Vtk::Puppet*>(obj)) {
+            props = &puppet->GetDisplayProperties();
+        } else {
+            // If it's not a puppet but displayOnly is requested, showing nothing or fallback?
+            // Fallback: core properties.
+        }
+    }
+
+    // Group properties by their group string
+    std::map<std::string, std::vector<::uLib::PropertyBase*>> groupedProps;
+    std::vector<std::string> groupOrder;
+    
+    for (auto* prop : *props) {
+        std::string group = prop->GetGroup();
+        if (groupedProps.find(group) == groupedProps.end()) {
+            groupOrder.push_back(group);
+        }
+        groupedProps[group].push_back(prop);
+    }
+
+    for (const auto& groupName : groupOrder) {
+        if (!groupName.empty()) {
+            m_ContainerLayout->addWidget(new GroupHeaderWidget(QString::fromStdString(groupName), m_Container));
+        }
+
+        for (auto* prop : groupedProps[groupName]) {
+            QWidget* widget = nullptr;
+            
+            // Priority 1: Check if it provides enum labels
+            if (!prop->GetEnumLabels().empty()) {
+                widget = new EnumPropertyWidget(prop, m_Container);
+            } else if (prop->GetUnits() == "color") {
+                // Color Picker for Vector3d
+                if (auto* pvec = dynamic_cast<Property<Vector3d>*>(prop)) {
+                    widget = new ColorPropertyWidget(pvec, m_Container);
+                }
+            } else if (prop->HasRange()) {
+                // Slider for ranged doubles
+                if (auto* pdbl = dynamic_cast<Property<double>*>(prop)) {
+                    widget = new RangePropertyWidget(pdbl, m_Container);
+                } else if (auto* pflt = dynamic_cast<Property<float>*>(prop)) {
+                     // widget = new RangePropertyWidget<float>(pflt, m_Container);
+                }
+            } else {
+                // Priority 2: Standard factory lookup
+                auto it = m_Factories.find(prop->GetTypeIndex());
+                if (it != m_Factories.end()) {
+                    widget = it->second(prop, m_Container);
+                } else {
+                    // Debug info for unknown types
+                    std::cout << "PropertyEditor: No factory for " << prop->GetQualifiedName() 
+                              << " (Type: " << prop->GetTypeName() << ")" << std::endl;
+
+                    widget = new PropertyWidgetBase(prop, m_Container);
+                    widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
+                }
+            }
+
+            if (widget) {
+                if (!groupName.empty()) {
+                    // Indent grouped properties
+                    widget->setContentsMargins(16, 0, 0, 0);
+                }
+                m_ContainerLayout->addWidget(widget);
+            }
+        }
+    }
+    m_ContainerLayout->addStretch(1);
+}
+
+void PropertyEditor::clear() {
+    QLayoutItem* item;
+    while ((item = m_ContainerLayout->takeAt(0)) != nullptr) {
+        delete item->widget();
+        delete item;
+    }
+}
+
+} // namespace Qt
+} // namespace uLib

app/gcompose/src/PropertyWidgets.h

@@ -0,0 +1,218 @@
+#ifndef PROPERTY_WIDGETS_H
+#define PROPERTY_WIDGETS_H
+
+#include <QWidget>
+class QPushButton;
+class QSlider;
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QLineEdit>
+#include <QCheckBox>
+#include <QScrollArea>
+#include <map>
+#include <typeindex>
+#include <functional>
+
+#include "Core/Property.h"
+#include "Core/Object.h"
+#include "Core/Signal.h"
+#include "Math/Dense.h"
+#include "Settings.h"
+
+namespace uLib {
+namespace Qt {
+
+double parseWithUnits(const QString& text, double* factorOut = nullptr, QString* suffixOut = nullptr);
+
+class PropertyWidgetBase : public QWidget {
+    Q_OBJECT
+public:
+    PropertyWidgetBase(PropertyBase* prop, QWidget* parent = nullptr);
+    virtual ~PropertyWidgetBase();
+    PropertyBase* getProperty() const { return m_BaseProperty; }
+
+protected:
+    PropertyBase* m_BaseProperty;
+    QHBoxLayout* m_Layout;
+    QLabel* m_Label;
+    // Stores the uLib signal connection so it can be disconnected on destruction,
+    // preventing use-after-free when PropertyEditor::clear() deletes widgets.
+    Connection m_Connection;
+};
+
+class UnitLineEdit : public QLineEdit {
+    Q_OBJECT
+public:
+    UnitLineEdit(QWidget* parent = nullptr);
+    void setValue(double val);
+    void setUnits(const QString& suffix, double factor = 1.0);
+    double getValue() const { return m_Value; }
+    void setIntegerOnly(bool b);
+
+signals:
+    void valueManualChanged(double val);
+
+private slots:
+    void onEditingFinished();
+
+private:
+    void updateText();
+    double m_Value;
+    double m_Factor;
+    QString m_Suffix;
+    bool m_IsInteger;
+};
+
+class DoublePropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    DoublePropertyWidget(Property<double>* prop, QWidget* parent = nullptr);
+private:
+    Property<double>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+class FloatPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    FloatPropertyWidget(Property<float>* prop, QWidget* parent = nullptr);
+private:
+    Property<float>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+class IntPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    IntPropertyWidget(Property<int>* prop, QWidget* parent = nullptr);
+private:
+    Property<int>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+template <typename VecT, int Size>
+class VectorPropertyWidget : public PropertyWidgetBase {
+public:
+    VectorPropertyWidget(Property<VecT>* prop, QWidget* parent = nullptr)
+        : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+        
+        std::string unit = prop->GetUnits();
+        double factor = 1.0;
+        QString prefSuffix;
+        if (!unit.empty()) {
+            auto dim = Settings::Instance().IdentifyDimension(unit);
+            std::string pref = Settings::Instance().GetPreferredUnit(dim);
+            factor = Settings::Instance().GetUnitFactor(pref);
+            prefSuffix = QString::fromStdString(pref);
+        }
+
+        for (int i = 0; i < Size; ++i) {
+            m_Edits[i] = new UnitLineEdit(this);
+            if (std::is_integral<typename VecT::Scalar>::value) {
+                m_Edits[i]->setIntegerOnly(true);
+            }
+            if (!prefSuffix.isEmpty()) {
+               m_Edits[i]->setUnits(prefSuffix, factor);
+            }
+            m_Edits[i]->setEnabled(!prop->IsReadOnly());
+            m_Layout->addWidget(m_Edits[i], 1);
+            
+            connect(m_Edits[i], &UnitLineEdit::valueManualChanged, [this, i](double val){
+                VecT v = m_Prop->Get();
+                v(i) = (typename VecT::Scalar)val;
+                if (m_Prop->Get() != v) m_Prop->Set(v);
+            });
+        }
+        updateEdits();
+        m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::Updated, [this](){
+            updateEdits();
+        });
+    }
+    ~VectorPropertyWidget() { m_Connection.disconnect(); }
+
+private:
+    void updateEdits() {
+        VecT v = m_Prop->Get();
+        for (int i = 0; i < Size; ++i) {
+            if (!m_Edits[i]->hasFocus()) {
+                m_Edits[i]->setValue((double)v(i));
+            }
+        }
+    }
+    Property<VecT>* m_Prop;
+    UnitLineEdit* m_Edits[Size];
+};
+
+class RangePropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    RangePropertyWidget(Property<double>* prop, QWidget* parent = nullptr);
+    virtual ~RangePropertyWidget();
+private slots:
+    void onSliderChanged(int val);
+private:
+    void updateUi();
+    Property<double>* m_Prop;
+    QSlider* m_Slider;
+    UnitLineEdit* m_Edit;
+};
+
+class BoolPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    BoolPropertyWidget(Property<bool>* prop, QWidget* parent = nullptr);
+    virtual ~BoolPropertyWidget();
+private:
+    Property<bool>* m_Prop;
+    QCheckBox* m_CheckBox;
+};
+
+class ColorPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    ColorPropertyWidget(Property<Vector3d>* prop, QWidget* parent = nullptr);
+    virtual ~ColorPropertyWidget();
+private slots:
+    void onClicked();
+private:
+    void updateButtonColor();
+    Property<Vector3d>* m_Prop;
+    QPushButton* m_Button;
+};
+
+class StringPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    StringPropertyWidget(Property<std::string>* prop, QWidget* parent = nullptr);
+    virtual ~StringPropertyWidget();
+private:
+    Property<std::string>* m_Prop;
+    QLineEdit* m_LineEdit;
+};
+
+class PropertyEditor : public QWidget {
+    Q_OBJECT
+public:
+    PropertyEditor(QWidget* parent = nullptr);
+    virtual ~PropertyEditor();
+    void setObject(uLib::Object* obj, bool displayOnly = false);
+    template<typename T>
+    void registerFactory(std::function<QWidget*(PropertyBase*, QWidget*)> factory) {
+        m_Factories[std::type_index(typeid(T))] = factory;
+    }
+
+private:
+    void clear();
+    uLib::Object* m_Object;
+    QVBoxLayout* m_MainLayout;
+    QScrollArea* m_ScrollArea;
+    QWidget* m_Container;
+    QVBoxLayout* m_ContainerLayout;
+    std::map<std::type_index, std::function<QWidget*(PropertyBase*, QWidget*)>> m_Factories;
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif // PROPERTY_WIDGETS_H

app/gcompose/src/QViewportPane.cpp

@@ -0,0 +1,231 @@
+#include "QViewportPane.h"
+#include <Vtk/vtkQViewport.h>
+#include <Root/QCanvas.h>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QToolButton>
+#include <QMenu>
+#include <QAction>
+#include <QSplitter>
+#include <vtkCamera.h>
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+
+QViewportPane::QViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullptr) {
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 0, 0);
+
+    m_titleLabel = new QLabel("Viewport", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    
+    m_toggleBtn = new QPushButton("Display", m_titleBar);
+    m_toggleBtn->setCheckable(true);
+    m_toggleBtn->setFixedSize(60, 18);
+    m_toggleBtn->setObjectName("DisplayToggleBtn");
+
+    auto* closeBtn = new QToolButton(m_titleBar);
+    closeBtn->setObjectName("PaneCloseButton");
+    closeBtn->setText("X");
+    closeBtn->setFixedSize(18, 18);
+
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+    titleLayout->addWidget(m_toggleBtn);
+    titleLayout->addSpacing(5);
+    titleLayout->addWidget(closeBtn);
+
+    m_layout->addWidget(m_titleBar);
+
+    // Main horizontal container for viewport and display panel
+    QWidget* mainArea = new QWidget(this);
+    QHBoxLayout* hLayout = new QHBoxLayout(mainArea);
+    hLayout->setContentsMargins(0, 0, 0, 0);
+    hLayout->setSpacing(0);
+    m_layout->addWidget(mainArea);
+
+    // Viewport will be added here via setViewport
+    m_viewport = new uLib::Vtk::QViewport(mainArea);
+    hLayout->addWidget(m_viewport);
+
+    // Display Panel (Overlay/Slide-out)
+    m_displayPanel = new QFrame(mainArea);
+    m_displayPanel->setObjectName("DisplayPropertiesPanel");
+    m_displayPanel->setFixedWidth(250);
+    m_displayPanel->hide();
+    
+    QVBoxLayout* panelLayout = new QVBoxLayout(m_displayPanel);
+    panelLayout->setContentsMargins(5, 5, 5, 5);
+    
+    QLabel* panelHeader = new QLabel("Display Properties", m_displayPanel);
+    panelHeader->setStyleSheet("font-weight: bold; padding: 5px;");
+    panelLayout->addWidget(panelHeader);
+
+    m_displayEditor = new uLib::Qt::PropertyEditor(m_displayPanel);
+    panelLayout->addWidget(m_displayEditor);
+    
+    hLayout->addWidget(m_displayPanel);
+
+    connect(m_toggleBtn, &QPushButton::toggled, this, &QViewportPane::toggleDisplayPanel);
+    connect(m_titleBar, &QWidget::customContextMenuRequested, this, &QViewportPane::showContextMenu);
+    connect(closeBtn, &QToolButton::clicked, this, &QViewportPane::onCloseRequested);
+
+    m_titleBar->setContextMenuPolicy(Qt::CustomContextMenu);
+}
+
+void QViewportPane::toggleDisplayPanel() {
+    m_displayPanel->setVisible(m_toggleBtn->isChecked());
+}
+
+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?
+    // 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);
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    auto* mainAreaLayout = static_cast<QHBoxLayout*>(m_displayPanel->parentWidget()->layout());
+    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");
+}
+
+void QViewportPane::addRootCanvas() {
+    auto* canvas = new uLib::Root::QCanvas(this);
+    setViewport(canvas, "ROOT Canvas");
+}
+
+void QViewportPane::onCloseRequested() {
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(parentWidget());
+    if (parentSplitter && parentSplitter->count() > 1) {
+        deleteLater();
+    } else {
+        // Can't close the last viewport in the splitter safely. Re-initialize to default VTK canvas.
+        addVtkViewport();
+    }
+}
+
+void QViewportPane::showContextMenu(const QPoint& pos) {
+    QMenu menu(this);
+    QAction* hSplit = menu.addAction("H split");
+    QAction* vSplit = menu.addAction("V split");
+    menu.addSeparator();
+    
+    bool isVtk = (qobject_cast<uLib::Vtk::QViewport*>(m_viewport) != nullptr);
+
+    QAction* changeType = menu.addAction(isVtk ? "Change to ROOT Canvas" : "Change to VTK Viewport");
+
+    QAction* selected = menu.exec(m_titleBar->mapToGlobal(pos));
+    
+    if (selected == hSplit) {
+        AttemptSplit(Qt::Horizontal);
+    } else if (selected == vSplit) {
+        AttemptSplit(Qt::Vertical);
+    } else if (selected == changeType) {
+        if (isVtk) {
+            addRootCanvas();
+        } else {
+            addVtkViewport();
+        }
+    }
+}
+
+void QViewportPane::AttemptSplit(Qt::Orientation orientation) {
+    QWidget* p = parentWidget();
+    if (!p) return;
+
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(p);
+    if (!parentSplitter) return;
+
+    QViewportPane* newPane = new QViewportPane();
+
+    // 1. Synchronize viewport content and camera (VTK Viewport only for now)
+    auto* currentVtk = qobject_cast<uLib::Vtk::QViewport*>(m_viewport);
+    if (currentVtk) {
+        auto* newVtk = qobject_cast<uLib::Vtk::QViewport*>(newPane->currentViewport());
+        if (newVtk) {
+            // Copy puppets
+            for (auto* puppet : currentVtk->getPuppets()) {
+                newVtk->AddPuppet(*puppet);
+            }
+            // Copy camera
+            if (currentVtk->GetRenderer() && newVtk->GetRenderer()) {
+                vtkCamera* currentCam = currentVtk->GetRenderer()->GetActiveCamera();
+                vtkCamera* newCam = newVtk->GetRenderer()->GetActiveCamera();
+                if (currentCam && newCam) {
+                    newCam->DeepCopy(currentCam);
+                }
+            }
+            // Sync grid visible and axis
+            newVtk->SetGridVisible(currentVtk->GetGridVisible());
+            newVtk->SetGridAxis(currentVtk->GetGridAxis());
+        }
+    }
+
+    // 2. Adjust for ROOT Canvas if that was the active view
+    bool isRoot = (qobject_cast<uLib::Root::QCanvas*>(m_viewport) != nullptr);
+    if (isRoot) {
+        newPane->addRootCanvas();
+    }
+
+    if (parentSplitter->orientation() == orientation) {
+        int index = parentSplitter->indexOf(this);
+        QList<int> sizes = parentSplitter->sizes();
+        int currentSize = sizes.value(index, 0);
+        int half = currentSize / 2;
+        sizes[index] = half;
+        sizes.insert(index + 1, currentSize - half);
+        
+        parentSplitter->insertWidget(index + 1, newPane);
+        parentSplitter->setSizes(sizes);
+    } else {
+        int index = parentSplitter->indexOf(this);
+        QList<int> parentSizes = parentSplitter->sizes();
+        
+        QSplitter* newSplitter = new QSplitter(orientation);
+        newSplitter->addWidget(this);
+        newSplitter->addWidget(newPane);
+        
+        QList<int> subSizes;
+        subSizes << 500 << 500;
+        newSplitter->setSizes(subSizes);
+        
+        parentSplitter->insertWidget(index, newSplitter);
+        parentSplitter->setSizes(parentSizes);
+    }
+}

app/gcompose/src/QViewportPane.h

@@ -0,0 +1,50 @@
+#ifndef QVIEWPORTPANE_H
+#define QVIEWPORTPANE_H
+
+#include <QWidget>
+#include <QFrame>
+#include <QPushButton>
+
+namespace uLib {
+    class Object;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QVBoxLayout;
+class QLabel;
+
+class QViewportPane : public QWidget {
+    Q_OBJECT
+public:
+    explicit QViewportPane(QWidget* parent = nullptr);
+    virtual ~QViewportPane();
+
+    void addVtkViewport();
+    void addRootCanvas();
+
+    QWidget* currentViewport() const { return m_viewport; }
+    
+    /** @brief Update the display properties for the given object. */
+    void setObject(uLib::Object* obj);
+
+private slots:
+    void onCloseRequested();
+    void showContextMenu(const QPoint& pos);
+    void toggleDisplayPanel();
+
+private:
+    void AttemptSplit(Qt::Orientation orientation);
+    void setViewport(QWidget* viewport, const QString& title);
+
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    QWidget* m_viewport;
+
+    // Display Properties Overlay
+    QFrame* m_displayPanel;
+    uLib::Qt::PropertyEditor* m_displayEditor;
+    QPushButton* m_toggleBtn;
+};
+
+#endif // QVIEWPORTPANE_H

app/gcompose/src/Settings.h

@@ -0,0 +1,75 @@
+#ifndef GCOMPOSE_SETTINGS_H
+#define GCOMPOSE_SETTINGS_H
+
+#include <string>
+#include <map>
+#include "Math/Units.h"
+
+namespace uLib {
+namespace Qt {
+
+class Settings {
+public:
+    static Settings& Instance() {
+        static Settings instance;
+        return instance;
+    }
+
+    enum Dimension {
+        Length,
+        Angle,
+        Energy,
+        Time,
+        Dimensionless
+    };
+
+    void SetPreferredUnit(Dimension dim, const std::string& unit) {
+        m_PreferredUnits[dim] = unit;
+    }
+
+    std::string GetPreferredUnit(Dimension dim) const {
+        auto it = m_PreferredUnits.find(dim);
+        if (it != m_PreferredUnits.end()) return it->second;
+        
+        switch(dim) {
+            case Length: return "mm";
+            case Angle: return "deg";
+            case Energy: return "MeV";
+            case Time: return "ns";
+            default: return "";
+        }
+    }
+
+    double GetUnitFactor(const std::string& unit) const {
+        if (unit == "m") return CLHEP::meter;
+        if (unit == "cm") return CLHEP::centimeter;
+        if (unit == "mm") return CLHEP::millimeter;
+        if (unit == "um") return CLHEP::micrometer;
+        if (unit == "deg") return CLHEP::degree;
+        if (unit == "rad") return CLHEP::radian;
+        if (unit == "ns") return CLHEP::nanosecond;
+        if (unit == "s") return CLHEP::second;
+        if (unit == "ms") return CLHEP::millisecond;
+        if (unit == "MeV") return CLHEP::megaelectronvolt;
+        if (unit == "GeV") return CLHEP::gigaelectronvolt;
+        if (unit == "eV") return CLHEP::electronvolt;
+        return 1.0;
+    }
+
+    Dimension IdentifyDimension(const std::string& unit) const {
+        if (unit == "m" || unit == "cm" || unit == "mm" || unit == "um" || unit == "nm") return Length;
+        if (unit == "deg" || unit == "rad") return Angle;
+        if (unit == "MeV" || unit == "GeV" || unit == "eV" || unit == "keV" || unit == "TeV") return Energy;
+        if (unit == "ns" || unit == "s" || unit == "ms" || unit == "us") return Time;
+        return Dimensionless;
+    }
+
+private:
+    Settings() {}
+    std::map<Dimension, std::string> m_PreferredUnits;
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif

app/gcompose/src/StyleManager.cpp

@@ -0,0 +1,98 @@
+#include "StyleManager.h"
+#include <QApplication>
+
+static const QString DARK_THEME = R"(
+QWidget#MenuPanel { background-color: #2b2b2b; border-bottom: 1px solid #111; }
+QLabel#LogoLabel { font-weight: bold; color: #0078d7; font-size: 14px; letter-spacing: 1px; }
+QPushButton#MenuButton { background: transparent; color: #ccc; border: none; padding: 5px 10px; }
+QPushButton#MenuButton:hover { background: #3c3c3c; color: white; border-radius: 4px; }
+QWidget#PaneTitleBar { background-color: #333; color: white; border-bottom: 2px solid #222; }
+QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
+QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #ccc; }
+QToolButton#PaneCloseButton:hover { color: white; background: #c42b1c; }
+
+/* Global & Panel Backgrounds */
+QMainWindow, QWidget#MainPanel { background-color: #1e1e1e; }
+QWidget#DisplayPropertiesPanel, QWidget#PropertiesPanel, QWidget#ContextPanel { background-color: #252526; border-left: 1px solid #3e3e42; }
+QPushButton#DisplayToggleBtn { background-color: #333337; border: 1px solid #3e3e42; border-radius: 2px; color: #f1f1f1; font-size: 11px; }
+QPushButton#DisplayToggleBtn:checked { background-color: #0078d7; color: white; border-color: #005a9e; font-weight: bold; }
+QPushButton#DisplayToggleBtn:hover { border-color: #0078d7; }
+
+QScrollArea { border: none; background: transparent; }
+QScrollArea > QWidget > QWidget { background: transparent; }
+
+/* Property Widgets Styling */
+QLabel { color: #cccccc; }
+QDoubleSpinBox, QSpinBox, QLineEdit { background: #3c3c3c; color: #f1f1f1; border: 1px solid #3e3e42; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
+QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
+QCheckBox { color: #cccccc; spacing: 5px; }
+QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #3e3e42; background: #333337; border-radius: 2px; }
+QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
+QCheckBox::indicator:hover { border-color: #0078d7; }
+
+QMenu { background-color: #2b2b2b; color: white; border: 1px solid #111; }
+QMenu::item:selected { background-color: #3c3c3c; }
+QTreeView#ContextTree { background-color: #1e1e1e; color: #ccc; border: none; }
+QTreeView#ContextTree::item:hover { background-color: #2a2d2e; }
+QTreeView#ContextTree::item:selected { background-color: #094771; color: white; }
+QHeaderView::section { background-color: #252526; color: #ccc; border: 1px solid #323233; padding: 4px; }
+
+/* ScrollBars */
+QScrollBar:vertical { background: #1e1e1e; width: 12px; margin: 0px; }
+QScrollBar::handle:vertical { background: #3e3e42; min-height: 20px; border-radius: 6px; margin: 2px; }
+QScrollBar::handle:vertical:hover { background: #505050; }
+QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
+)";
+
+static const QString BRIGHT_THEME = R"(
+QWidget#MenuPanel { background-color: #f3f3f3; border-bottom: 1px solid #ccc; }
+QLabel#LogoLabel { font-weight: bold; color: #005a9e; font-size: 14px; letter-spacing: 1px; }
+QPushButton#MenuButton { background: transparent; color: #333; border: none; padding: 5px 10px; }
+QPushButton#MenuButton:hover { background: #e5e5e5; color: black; border-radius: 4px; }
+QWidget#PaneTitleBar { background-color: #eeeeee; color: black; border-bottom: 2px solid #ddd; }
+QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
+QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #666; }
+QToolButton#PaneCloseButton:hover { color: white; background: #e81123; }
+
+/* Global & Panel Backgrounds */
+QMainWindow, QWidget#MainPanel { background-color: #f3f3f3; }
+QWidget#DisplayPropertiesPanel, QWidget#PropertiesPanel, QWidget#ContextPanel { background-color: #ffffff; border-left: 1px solid #cccccc; }
+QPushButton#DisplayToggleBtn { background-color: #ffffff; border: 1px solid #cccccc; border-radius: 2px; color: #333; font-size: 11px; }
+QPushButton#DisplayToggleBtn:checked { background-color: #0078d7; color: white; border-color: #005a9e; font-weight: bold; }
+QPushButton#DisplayToggleBtn:hover { border-color: #0078d7; }
+
+QScrollArea { border: none; background: transparent; }
+QScrollArea > QWidget > QWidget { background: transparent; }
+
+/* Property Widgets Styling */
+QLabel { color: #333333; }
+QDoubleSpinBox, QSpinBox, QLineEdit { background: #ffffff; color: #333333; border: 1px solid #cccccc; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
+QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
+QCheckBox { color: #333333; spacing: 5px; }
+QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #cccccc; background: #ffffff; border-radius: 2px; }
+QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
+QCheckBox::indicator:hover { border-color: #0078d7; }
+
+QMenu { background-color: #f3f3f3; color: black; border: 1px solid #ccc; }
+QMenu::item:selected { background-color: #d0d0d0; }
+QTreeView#ContextTree { background-color: #ffffff; color: #333; border: none; }
+QTreeView#ContextTree::item:hover { background-color: #f2f2f2; }
+QTreeView#ContextTree::item:selected { background-color: #0078d7; color: white; }
+QHeaderView::section { background-color: #f3f3f3; color: #333; border: 1px solid #ccc; padding: 4px; }
+
+/* ScrollBars */
+QScrollBar:vertical { background: #ffffff; width: 12px; margin: 0px; }
+QScrollBar::handle:vertical { background: #cccccc; min-height: 20px; border-radius: 6px; margin: 2px; }
+QScrollBar::handle:vertical:hover { background: #aaaaaa; }
+QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
+)";
+
+void StyleManager::applyStyle(QApplication* app, const QString& themeName) {
+    if (!app) return;
+    
+    if (themeName == "bright") {
+        app->setStyleSheet(BRIGHT_THEME);
+    } else {
+        app->setStyleSheet(DARK_THEME); // default
+    }
+}

app/gcompose/src/StyleManager.h

@@ -0,0 +1,13 @@
+#ifndef STYLEMANAGER_H
+#define STYLEMANAGER_H
+
+#include <QString>
+
+class QApplication;
+
+class StyleManager {
+public:
+    static void applyStyle(QApplication* app, const QString& themeName);
+};
+
+#endif // STYLEMANAGER_H

app/gcompose/src/ViewportPane.cpp

@@ -0,0 +1,187 @@
+#include "ViewportPane.h"
+#include <Vtk/vtkQViewport.h>
+#include <Root/QCanvas.h>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QToolButton>
+#include <QMenu>
+#include <QAction>
+#include <QSplitter>
+#include <vtkCamera.h>
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+
+ViewportPane::ViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullptr) {
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 0, 0);
+
+    m_titleLabel = new QLabel("Viewport", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    
+    m_toggleBtn = new QPushButton("Display", m_titleBar);
+    m_toggleBtn->setCheckable(true);
+    m_toggleBtn->setFixedSize(60, 18);
+    m_toggleBtn->setObjectName("DisplayToggleBtn");
+
+    auto* closeBtn = new QToolButton(m_titleBar);
+    closeBtn->setObjectName("PaneCloseButton");
+    closeBtn->setText("X");
+    closeBtn->setFixedSize(18, 18);
+
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+    titleLayout->addWidget(m_toggleBtn);
+    titleLayout->addSpacing(5);
+    titleLayout->addWidget(closeBtn);
+
+    m_layout->addWidget(m_titleBar);
+
+    // Main area with splitter for viewport and display panel
+    m_areaSplitter = new QSplitter(Qt::Horizontal, this);
+    m_areaSplitter->setObjectName("ViewportAreaSplitter");
+    m_layout->addWidget(m_areaSplitter, 1);
+
+    // Viewport will be added here via setViewport
+    m_viewport = new uLib::Vtk::QViewport(m_areaSplitter);
+    m_areaSplitter->addWidget(m_viewport);
+
+    // Display Panel (Overlay/Slide-out)
+    m_displayPanel = new QFrame(m_areaSplitter);
+    m_displayPanel->setObjectName("DisplayPropertiesPanel");
+    m_displayPanel->setMinimumWidth(150);
+    m_displayPanel->hide();
+    
+    m_areaSplitter->addWidget(m_displayPanel);
+    m_areaSplitter->setStretchFactor(0, 1);
+    m_areaSplitter->setStretchFactor(1, 0);
+    
+    QVBoxLayout* panelLayout = new QVBoxLayout(m_displayPanel);
+    panelLayout->setContentsMargins(5, 5, 5, 5);
+    
+    QLabel* panelHeader = new QLabel("Display Properties", m_displayPanel);
+    panelHeader->setStyleSheet("font-weight: bold; padding: 5px;");
+    panelLayout->addWidget(panelHeader);
+
+    m_displayEditor = new uLib::Qt::PropertyEditor(m_displayPanel);
+    panelLayout->addWidget(m_displayEditor);
+
+    connect(m_toggleBtn, &QPushButton::toggled, this, &ViewportPane::toggleDisplayPanel);
+    connect(m_titleBar, &QWidget::customContextMenuRequested, this, &ViewportPane::showContextMenu);
+    connect(closeBtn, &QToolButton::clicked, this, &ViewportPane::onCloseRequested);
+
+    m_titleBar->setContextMenuPolicy(Qt::CustomContextMenu);
+}
+
+ViewportPane::~ViewportPane() {}
+
+void ViewportPane::toggleDisplayPanel() {
+    bool visible = m_toggleBtn->isChecked();
+    m_displayPanel->setVisible(visible);
+    if (visible && m_areaSplitter->sizes().value(1, 0) == 0) {
+        QList<int> sizes = m_areaSplitter->sizes();
+        int total = sizes[0] + sizes[1];
+        sizes[1] = 250;
+        sizes[0] = total - 250;
+        m_areaSplitter->setSizes(sizes);
+    }
+}
+
+void ViewportPane::setObject(uLib::Object* obj) {
+    m_displayEditor->setObject(obj, true);
+    
+    // Check if the object is a Puppet (meaning it has display properties)
+    bool isPuppet = (dynamic_cast<::uLib::Vtk::Puppet*>(obj) != nullptr);
+    
+    // Only show the "Display" toggle button if it's a puppet
+    m_toggleBtn->setVisible(isPuppet);
+    
+    // If it's a puppet, 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.
+    if (!isPuppet) {
+        m_toggleBtn->setChecked(false);
+        m_displayPanel->hide();
+    }
+}
+
+void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
+    if (m_viewport) {
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    m_areaSplitter->insertWidget(0, m_viewport);
+    m_areaSplitter->setStretchFactor(0, 1);
+}
+
+void ViewportPane::addVtkViewport() {
+    auto* viewport = new uLib::Vtk::QViewport(this);
+    setViewport(viewport, "VTK Viewport");
+}
+
+void ViewportPane::addRootCanvas() {
+    auto* canvas = new uLib::Root::QCanvas(this);
+    setViewport(canvas, "ROOT Canvas");
+}
+
+void ViewportPane::onCloseRequested() {
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(parentWidget());
+    if (parentSplitter && parentSplitter->count() > 1) {
+        deleteLater();
+    } else {
+        addVtkViewport();
+    }
+}
+
+void ViewportPane::showContextMenu(const QPoint& pos) {
+    QMenu menu(this);
+    QAction* hSplit = menu.addAction("H split");
+    QAction* vSplit = menu.addAction("V split");
+    menu.addSeparator();
+    bool isVtk = (qobject_cast<uLib::Vtk::QViewport*>(m_viewport) != nullptr);
+    QAction* changeType = menu.addAction(isVtk ? "Change to ROOT Canvas" : "Change to VTK Viewport");
+    QAction* selected = menu.exec(m_titleBar->mapToGlobal(pos));
+    if (selected == hSplit) AttemptSplit(Qt::Horizontal);
+    else if (selected == vSplit) AttemptSplit(Qt::Vertical);
+    else if (selected == changeType) isVtk ? addRootCanvas() : addVtkViewport();
+}
+
+void ViewportPane::AttemptSplit(Qt::Orientation orientation) {
+    QWidget* p = parentWidget();
+    if (!p) return;
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(p);
+    if (!parentSplitter) return;
+    ViewportPane* newPane = new ViewportPane();
+    if (parentSplitter->orientation() == orientation) {
+        int index = parentSplitter->indexOf(this);
+        QList<int> sizes = parentSplitter->sizes();
+        int currentSize = sizes.value(index, 0);
+        int half = currentSize / 2;
+        sizes[index] = half;
+        sizes.insert(index + 1, currentSize - half);
+        parentSplitter->insertWidget(index + 1, newPane);
+        parentSplitter->setSizes(sizes);
+    } else {
+        int index = parentSplitter->indexOf(this);
+        QList<int> parentSizes = parentSplitter->sizes();
+        QSplitter* newSplitter = new QSplitter(orientation);
+        newSplitter->addWidget(this);
+        newSplitter->addWidget(newPane);
+        QList<int> subSizes;
+        subSizes << 500 << 500;
+        newSplitter->setSizes(subSizes);
+        parentSplitter->insertWidget(index, newSplitter);
+        parentSplitter->setSizes(parentSizes);
+    }
+}

app/gcompose/src/ViewportPane.h

@@ -0,0 +1,52 @@
+#ifndef VIEWPORTPANE_H
+#define VIEWPORTPANE_H
+
+#include <QWidget>
+#include <QFrame>
+#include <QPushButton>
+
+namespace uLib {
+    class Object;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QSplitter;
+class QVBoxLayout;
+class QLabel;
+
+class ViewportPane : public QWidget {
+    Q_OBJECT
+public:
+    explicit ViewportPane(QWidget* parent = nullptr);
+    virtual ~ViewportPane();
+
+    void addVtkViewport();
+    void addRootCanvas();
+
+    QWidget* currentViewport() const { return m_viewport; }
+    
+    /** @brief Update the display properties for the given object. */
+    void setObject(uLib::Object* obj);
+
+private slots:
+    void onCloseRequested();
+    void showContextMenu(const QPoint& pos);
+    void toggleDisplayPanel();
+
+private:
+    void AttemptSplit(Qt::Orientation orientation);
+    void setViewport(QWidget* viewport, const QString& title);
+
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    QSplitter* m_areaSplitter;
+    QWidget* m_viewport;
+
+    // Display Properties Overlay
+    QFrame* m_displayPanel;
+    uLib::Qt::PropertyEditor* m_displayEditor;
+    QPushButton* m_toggleBtn;
+};
+
+#endif // VIEWPORTPANE_H

app/gcompose/src/main.cpp

@@ -1,14 +1,19 @@
 #include <QApplication>
 #include "MainWindow.h"
+#include "MainPanel.h"
+#include "ViewportPane.h"
+#include "StyleManager.h"
 
 #include "Math/ContainerBox.h"
 #include <HEP/Geant/Scene.h>
 #include "HEP/Detectors/DetectorChamber.h"
 #include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 
-#include <Vtk/vtkContainerBox.h>
+#include <Vtk/Math/vtkContainerBox.h>
 #include <Vtk/vtkQViewport.h>
 
+#include "Core/ObjectsContext.h"
+
 #include <vtkSmartPointer.h>
 #include <vtkCubeSource.h>
 #include <vtkPolyDataMapper.h>
@@ -24,42 +29,25 @@ using namespace uLib::literals;
 
 int main(int argc, char** argv) {
     QApplication app(argc, argv);
+    StyleManager::applyStyle(&app, "dark");
     std::cout << "Starting gcompose Qt application..." << std::endl;
 
-    ContainerBox world_box(Vector3f(1, 1, 1));
-    world_box.Scale(Vector3f(20_mm, 20_mm, 20_mm));
+    // ContainerBox world_box(Vector3f(1, 1, 1));
+    // world_box.Scale(Vector3f(2_mm, 2_mm, 2_mm));
+    // world_box.SetPosition(Vector3f(-1_mm, -1_mm, -1_mm));    
 
-    DetectorChamber d1, d2;
-    d1.SetSize(Vector3f(1, 1, 1));
-    d1.SetPosition(Vector3f(0, 0, 0));
-    d1.Scale(Vector3f(5, 10, 2));
-    d1.Translate(Vector3f(0, 0, 0));
+    // Geant::Scene scene;
+    // scene.ConstructWorldBox(world_box.GetSize(), "G4_AIR");
+    // scene.Initialize();
 
-    d2.SetSize(Vector3f(1, 1, 1));
-    d2.SetPosition(Vector3f(0, 0, 0));
-    d2.Scale(Vector3f(5, 10, 2));
-    d2.Translate(Vector3f(0, 0, 10));
-    
-
-    Geant::Scene scene;
-    scene.ConstructWorldBox(world_box.GetSize(), "G4_AIR");
-    scene.Initialize();
+    uLib::ObjectsContext globalContext;
+    // globalContext.AddObject(&world_box);
+    // globalContext.AddObject(&scene);
 
     // 2. Initialize MainWindow (contains embedded VTK QViewport)
     MainWindow window;
-    Vtk::QViewport* viewport = window.getViewport();
-
-    Vtk::vtkDetectorChamber vtk_d1(&d1);
-    viewport->AddPuppet(vtk_d1);
-
-    Vtk::vtkDetectorChamber vtk_d2(&d2);
-    viewport->AddPuppet(vtk_d2);
-
-    Vtk::vtkContainerBox vtk_box(&world_box);
-    viewport->AddPuppet(vtk_box);
-
-    viewport->ZoomAuto();
-
+    window.setContext(&globalContext);
+    
     std::cout << "Geant4 and VTK scenes are ready." << std::endl;
     
     window.show();

docs/archives.md

@@ -0,0 +1,84 @@
+# Serialization and Archives Internals
+
+This document explains the internal design of the `uLib` serialization system, which is built on top of **Boost.Serialization**. It provides custom archive implementations for various formats (XML, Text, Logging) and introduces **Human Readable Pairs (HRP)** for metadata-rich serialization.
+
+---
+
+## Architecture Overview
+
+The `uLib` archive system extends the standard `boost::archive` templates to add domain-specific features. The main components are:
+
+1.  **Custom Interface Layer**: Extends the default Boost archive API with additional operators and utilities.
+2.  **Specialized Archive Implementations**: Specialized classes for XML, Text, and Logging.
+3.  **HRP Support**: First-class support for `hrp` (Human Readable Pair) wrappers, which carry units, ranges, and descriptions.
+4.  **Static Registration System**: Macros and explicit instantiations to handle polymorphic types and compilation isolation.
+
+---
+
+## Custom Interface Layer
+
+All `uLib` archives use a custom interface defined in `Archives.h` via `uLib_interface_iarchive` and `uLib_interface_oarchive`. These templates add several key features:
+
+| Feature | Operator/Method | Description |
+|---|---|---|
+| **Mapping Operator** | `operator==` | Aliased to `operator&` (Boost's standard mapping operator). |
+| **Trace Operator** | `operator!=` | Used for trace/debug output of strings during serialization. |
+| **Type Registration** | `register_type<T>()` | Registers a class type with the archive's internal serializer map. |
+| **Standard IO** | `operator<<` / `operator>>` | Standard redirect for saving and loading. |
+
+These interfaces are applied to the archives using template specialization of `boost::archive::detail::interface_iarchive` and `interface_oarchive`.
+
+---
+
+## Archive Variants
+
+### XML Archives (`xml_iarchive`, `xml_oarchive`)
+These inherit from `boost::archive::xml_iarchive_impl` and `xml_oarchive_impl`. 
+- **Internals**: They override `load_override` and `save_override` to handle `boost::serialization::hrp<T>` specifically. 
+- **XML Mapping**: When saving an `hrp`, it uses `save_start(name)` and `save_end(name)` to wrap the value in a named XML tag.
+
+### Text Archives (`text_iarchive`, `text_oarchive`)
+Standard text-based archives used for compact serialization. They use `StringReader` to consume decorative text markers during loading.
+
+### Human Readable Text (`hrt_iarchive`, `hrt_oarchive`)
+These are "naked" text archives that suppress most of Boost's internal metadata (object IDs, class IDs, versions).
+- **Goal**: Produce text output that is easy for humans to read and edit.
+- **Internals**: All overrides for Boost internal types (like `object_id_type`, `version_type`, etc.) are implemented as no-ops.
+
+### Log Archive (`log_archive`)
+An XML-based output archive specifically for debug logging.
+- **Internals**: It forces every object into a Name-Value Pair (NVP) even if not provided by the user, and strips all technical metadata to keep the logs clean.
+
+---
+
+## HRP (Human Readable Pair) Integration
+
+`hrp` is a core `uLib` wrapper (defined in `Serializable.h`) that extends Boost's `nvp`:
+
+```cpp
+// Example of HRP usage
+ar & HRP2("Energy", m_energy, "MeV").range(0, 100);
+```
+
+### Internal Handling in Archives
+Archives in `Archives.h` provide specific `save_override`/`load_override` for `hrp<T>`:
+- **XML**: Maps the `name()` to an XML tag.
+- **HRT**: Formats as `name: value [units]\n`.
+- **Log**: Converts it to a standard Boost `nvp` for consistent XML logging.
+
+---
+
+## Registration and Polymorphism
+
+### Registration Macro
+The `ULIB_SERIALIZATION_REGISTER_ARCHIVE(Archive)` macro is crucial for polymorphic serialization. It instantiates the necessary template machinery to link the custom `Archive` type with any `Serializable` class exported via `BOOST_CLASS_EXPORT`.
+
+### Explicit Instantiation
+To reduce compilation times and provide a single point of failure for link-time issues, `uLib` uses explicit instantiations in `src/Core/Archives.cpp`. This file includes the `.ipp` implementation files from Boost and instantiates the `archive_serializer_map` and implementation classes for all `uLib` archive types.
+
+---
+
+## Utility: StringReader
+The `StringReader` utility is used internally by text-based archives to parse and skip literals. For example:
+- When loading a string literal from a text archive, `StringReader` consumes whitespace and ensures the stream matches the expected string, failing if there is a mismatch.
+- This is vital for maintaining the structure of human-readable formats.

docs/geant_integration.md

@@ -0,0 +1,11 @@
+# Geant integration
+
+Geant4 integration in uLib is done through the `HEP/Geant` module.
+The module represets a set of wrapper for geant objects that are also deriving from uLib::Object so they can be used in the uLib::Object tree and visualized with the uLib::Vtk module and driven py properties.
+
+# Geant Solid integration
+
+Geant solid in uLib is represented by the `uLib::Geant::Solid` class and mainly BoxSolid and TessellatedSolid. The solids in Geant does not have the possibility to set properties on the fly so we need to create a new solid every time we want to change the properties of a solid. This is done by creating a new `uLib::Geant::Solid` object and setting the properties of the new solid. The new solid is then added to the `uLib::Geant::Solid` object as a child. The old solid is then removed from the `uLib::Geant::Solid` object as a child. The old solid is then deleted. However id some of the properties can be set then the library will drive the change in the solid update.
+
+The idea is to have a mapping of solid properties that can be used in uLib for Qt representation or vtk representation. then when the property is changed the signaling will update the property in uLib and then the solid will be updated. If the Geant property can be applied to the G4 object underneath then the update will apply the change, in case it is not possible to apply the change to the G4 object underneath then the G4 element will be recreated. 
+In any case a updated singal is emitted and the related element that use that solid is updated ( for instance the scene ).

docs/update_properties.md

@@ -0,0 +1,94 @@
+
+# Properties and the vtk-gui representation
+
+This is the rationale behind the connection between TRS properties and Puppet 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.
+
+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.
+
+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 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 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. 
+
+
+
+
+
+
+## ACTIVATE PROPERTIES
+
+ULIB_ACTIVATE_PROPERTIES must run after all member initialization, with the vtable pointing to the most-derived type. This is why it has to be in each constructor — in C++, virtual dispatch only works correctly after a class's vtable is installed, which happens at the start of each level's constructor body.
+
+### Option 1 — End-of-class macro (no constructor boilerplate)
+Declare a private member activator as the last member of the class. Its constructor runs after all other members, and at that point the vtable is already Derived's:
+
+
+// In Property.h, add alongside ULIB_ACTIVATE_PROPERTIES:
+#define ULIB_DECLARE_PROPERTIES(SelfType) \
+private: \
+    struct _PropActivator { \
+        _PropActivator(SelfType* self) { \
+            uLib::Archive::property_register_archive ar(self); \
+            ar & *self; \
+        } \
+    } _prop_activator{this};
+Usage in ContainerBox.h — place it just before the closing brace:
+
+
+class ContainerBox : public TRS {
+public:
+    // ... all constructors, no more ULIB_ACTIVATE_PROPERTIES(*this)
+
+    ULIB_DECLARE_PROPERTIES(ContainerBox)  // ← replaces all 3 constructor calls
+};
+Tradeoff: Works perfectly for single-level classes. For hierarchies where multiple levels use the macro, RegisterDynamicProperty must deduplicate by name (skip if already registered). Requires one line per class in the class body, but zero lines in constructors.
+
+### Option 2 — Lazy init via virtual InitProperties() in Object
+Modify Object to call a virtual hook on first GetProperties():
+
+
+// In Object.h:
+class Object {
+protected:
+    virtual void InitProperties() {}   // override in derived
+public:
+    const std::vector<PropertyBase*>& GetProperties() const {
+        if (!m_propertiesInitialized) {
+            const_cast<Object*>(this)->m_propertiesInitialized = true;
+            const_cast<Object*>(this)->InitProperties();
+        }
+        return m_properties;
+    }
+};
+Then a CRTP base handles the rest without any macro:
+
+
+template<typename Derived>
+class PropertyObject : public Object {
+protected:
+    void InitProperties() override {
+        uLib::Archive::property_register_archive ar(this);
+        ar & *static_cast<Derived*>(this);
+    }
+};
+Usage — just change the base class:
+
+
+class ContainerBox : public PropertyObject<ContainerBox>, public TRS { ... };
+// Nothing else needed — properties activated on first GetProperties() call
+Tradeoff: Most "automatic" — pure inheritance, no constructor or class-body macros. But requires modifying Object (adding m_propertiesInitialized flag + virtual hook), and lazy init means properties aren't available until first access. Also doesn't work well with multiple inheritance (which TRS likely involves).
+
+Option 3 — CRTP doesn't work from the base constructor
+Just to be explicit: a CRTP base that calls ULIB_ACTIVATE_PROPERTIES in its own constructor won't work, because when PropertyObject<Derived>'s constructor runs, the vtable is PropertyObject<Derived>'s — Derived::serialize() hasn't been installed yet. So ar & *self calls Object::serialize() (a no-op).
+
+Recommendation
+Option 1 is the least invasive and safest. Add deduplication to RegisterDynamicProperty in Object.cpp to guard against re-registration when hierarchies stack activators, then replace every ULIB_ACTIVATE_PROPERTIES(*this) in constructors with a single ULIB_DECLARE_PROPERTIES(ClassName) at the end of the class body.
+
+Option 2 is cleaner to use but requires changing the Object interface and has the lazy-init semantic change — only worth it if you want zero-touch activation across the entire framework.

src/Core/Archives.h

@@ -28,6 +28,8 @@
 
 #include <boost/archive/detail/basic_pointer_iserializer.hpp>
 #include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <cstring>
 #include <iostream>
 
 #include <boost/archive/text_iarchive.hpp>
@@ -59,6 +61,8 @@ class xml_iarchive;
 class xml_oarchive;
 class text_iarchive;
 class text_oarchive;
+class hrt_iarchive;
+class hrt_oarchive;
 class log_archive;
 
 } // namespace Archive
@@ -150,7 +154,7 @@ public:
   Archive *This() { return static_cast<Archive *>(this); }
 
   template <class T>
-  const basic_pointer_iserializer *register_type(T * = NULL) {
+  const basic_pointer_iserializer *register_type(T * = nullptr) {
     const basic_pointer_iserializer &bpis = boost::serialization::singleton<
         pointer_iserializer<Archive, T>>::get_const_instance();
     this->This()->register_basic_serializer(bpis.get_basic_serializer());
@@ -161,15 +165,36 @@ public:
     return *this->This();
   }
 
+  template <class T>
+  Archive &operator>>(const boost::serialization::nvp<T> &t) {
+    this->This()->load_override(t);
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp<T> &>(t));
+    return *this->This();
+  }
+
   // the & operator
   template <class T> Archive &operator&(T &t) { return *(this->This()) >> t; }
 
+  template <class T>
+  Archive &operator&(const boost::serialization::nvp<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp<T> &t) {
+    return *(this->This()) >> t;
+  }
+
   // the == operator
   template <class T> Archive &operator==(T &t) { return this->operator&(t); }
 
   // the != operator for human readable access
   template <class T> Archive &operator!=(T &t) {
-    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
     return *this->This();
   }
 };
@@ -191,27 +216,23 @@ public:
   Archive *This() { return static_cast<Archive *>(this); }
 
   template <class T>
-  const basic_pointer_oserializer *register_type(const T * = NULL) {
+  const basic_pointer_oserializer *register_type(const T * = nullptr) {
     const basic_pointer_oserializer &bpos = boost::serialization::singleton<
         pointer_oserializer<Archive, T>>::get_const_instance();
     this->This()->register_basic_serializer(bpos.get_basic_serializer());
     return &bpos;
   }
 
-  template <class T> Archive &operator<<(T &t) {
+  template <class T> Archive &operator<<(const T &t) {
     // to get access you must redefine save_override by typing
     // "using save_override" in archive impl
     this->This()->save_override(t);
     return *this->This();
   }
-
+ 
   // the & operator
-  template <class T> Archive &operator&(T &t) {
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    return *this->This() << const_cast<const T &>(t);
-#else
+  template <class T> Archive &operator&(const T &t) {
     return *this->This() << t;
-#endif
   }
 
   // the == operator
@@ -219,7 +240,6 @@ public:
 
   // the != operator for human readable access
   template <class T> Archive &operator!=(T &t) {
-    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
     return *this->This();
   }
 };
@@ -244,23 +264,22 @@ template <>
 class interface_oarchive<uLib::Archive::text_oarchive>
     : public uLib_interface_oarchive<uLib::Archive::text_oarchive> {};
 
+template <>
+class interface_iarchive<uLib::Archive::hrt_iarchive>
+    : public uLib_interface_iarchive<uLib::Archive::hrt_iarchive> {};
+
+template <>
+class interface_oarchive<uLib::Archive::hrt_oarchive>
+    : public uLib_interface_oarchive<uLib::Archive::hrt_oarchive> {};
+
+template <>
+class interface_iarchive<uLib::Archive::log_archive>
+    : public uLib_interface_iarchive<uLib::Archive::log_archive> {};
+
 template <>
 class interface_oarchive<uLib::Archive::log_archive>
     : public uLib_interface_oarchive<uLib::Archive::log_archive> {};
 
-//// Veritical repetition macro // FINIRE !!!!!!!!!!!!!!!!!!!!!!!!!
-// #define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata)           \
-//     template <class TypeSeq>                             \
-//     struct inherit_nofold<TypeSeq,BOOST_PP_INC(vn)> :    \
-//     BOOST_PP_REPEAT(BOOST_PP_INC(vn),_INERIT_NOFOLD_H,~) \
-//     {};
-
-//// Multiple size declaration //
-// BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
-
-// #undef  _INERIT_NOFOLD_H
-// #undef  _INERIT_NOFOLD_V
-
 } // namespace detail
 } // namespace archive
 } // namespace boost
@@ -279,36 +298,6 @@ class interface_oarchive<uLib::Archive::log_archive>
 namespace boost {
 namespace archive {
 
-// template<class Archive>
-// inline void load_const_override(Archive & ar, const char *t ){
-//     typedef typename mpl::identity<detail::load_non_pointer_type<Archive>
-//     >::type typex; typex::invoke(ar, t);
-// }
-
-// template<class Archive, class T>
-// inline void load(Archive & ar, T &t){
-//     // if this assertion trips. It means we're trying to load a
-//     // const object with a compiler that doesn't have correct
-//     // funtion template ordering.  On other compilers, this is
-//     // handled below.
-//     //    detail::check_const_loading< T >();
-//     typedef
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
-//             mpl::identity<detail::load_pointer_type<Archive> >
-//         ,//else
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
-//             mpl::identity<detail::load_array_type<Archive> >
-//         ,//else
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
-//             mpl::identity<detail::load_enum_type<Archive> >
-//         ,//else
-//             mpl::identity<detail::load_non_pointer_type<Archive> >
-//         >
-//         >
-//         >::type typex;
-//     typex::invoke(ar, t);
-// }
-
 } // namespace archive
 } // namespace boost
 
@@ -316,40 +305,38 @@ namespace uLib {
 
 namespace Archive {
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// POLYMORPHIC //
-
-// class polymorphic_iarchive :
-//         public boost::archive::polymorphic_iarchive {
-
-// public:
-//     void load_override(const char *t, BOOST_PFTO int)
-//     {
-//         boost::archive::load_const_override(* this->This(),
-//         const_cast<char*>(t));
-//     }
-
-//};
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // XML //
 
+// ULIB_SERIALIZATION_VERSION should be get from the build system
+#ifndef ULIB_SERIALIZATION_VERSION
+#define ULIB_SERIALIZATION_VERSION "0.0"
+#endif
+
 class xml_iarchive : public boost::archive::xml_iarchive_impl<xml_iarchive> {
   typedef xml_iarchive Archive;
   typedef boost::archive::xml_iarchive_impl<Archive> base;
 
+  unsigned int m_flags;
+
   // give serialization implementation access to this class
   friend class boost::archive::detail::interface_iarchive<Archive>;
   friend class boost::archive::basic_xml_iarchive<Archive>;
   friend class boost::archive::load_access;
-
 public:
   xml_iarchive(std::istream &is, unsigned int flags = 0)
-      : xml_iarchive_impl<xml_iarchive>(is, flags) {}
+      : boost::archive::xml_iarchive_impl<xml_iarchive>(
+            is, flags | boost::archive::no_header), m_flags(flags) {
+    if (0 == (flags & boost::archive::no_header)) {
+      std::string line;
+      std::getline(is, line); // <?xml ... ?>
+      std::getline(is, line); // <!DOCTYPE ...>
+      std::getline(is, line); // <ulib_serialization ...>
+    }
+  }
 
   using basic_xml_iarchive::load_override;
 
@@ -364,7 +351,6 @@ public:
       boost::serialization::hrp<T> &t) {
     this->This()->load_start(t.name());
     this->detail_common_iarchive::load_override(t.value());
-    //        t.stov();
     this->This()->load_end(t.name());
   }
 
@@ -374,17 +360,13 @@ public:
   using base::load_override;
 
   void load_override(const char *str) {
-    //        StringReader sr(basic_text_iprimitive::is);
-    //        sr >> str;
+    // StringReader sr(basic_text_iprimitive::is);
+    // sr >> str;
   }
 
-  ~xml_iarchive() {};
+  virtual ~xml_iarchive() {}
 };
 
-// typedef boost::archive::detail::polymorphic_iarchive_route<
-// boost::archive::xml_iarchive_impl<xml_iarchive>
-//> polymorphic_xml_iarchive;
-
 template <class ArchiveImpl>
 struct polymorphic_iarchive_route
     : boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl> {
@@ -394,31 +376,39 @@ struct polymorphic_iarchive_route
 class polymorphic_xml_iarchive
     : public polymorphic_iarchive_route<
           boost::archive::xml_iarchive_impl<xml_iarchive>> {
-  // give serialization implementation access to this class
-  //    friend class boost::archive::detail::interface_iarchive<Archive>;
-  //    friend class boost::archive::basic_xml_iarchive<Archive>;
-  //    friend class boost::archive::load_access;
 public:
-  virtual void load_override(const char *str) { ; }
+  virtual void load_override(const char *str) {}
 };
 
 class xml_oarchive : public boost::archive::xml_oarchive_impl<xml_oarchive> {
   typedef xml_oarchive Archive;
   typedef boost::archive::xml_oarchive_impl<Archive> base;
 
+  unsigned int m_flags;
+
   // give serialization implementation access to this class
   friend class boost::archive::detail::interface_oarchive<Archive>;
   friend class boost::archive::basic_xml_oarchive<Archive>;
   friend class boost::archive::save_access;
-
 public:
   xml_oarchive(std::ostream &os, unsigned int flags = 0)
-      : boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
+      : boost::archive::xml_oarchive_impl<xml_oarchive>(
+            os, flags | boost::archive::no_header), m_flags(flags) {
+    if (0 == (flags & boost::archive::no_header)) {
+      this->This()->put(
+          "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
+      this->This()->put("<!DOCTYPE ulib_serialization>\n");
+      this->This()->put("<ulib_serialization signature=\"serialization::archive\" ");
+      this->write_attribute("version", (const char *)ULIB_SERIALIZATION_VERSION);
+      this->This()->put(">\n");
+    }
+  }
 
-  // example of implementing save_override for const char* //
-  //    void save_override(const char *t, int) {
-  //        std::cout << "found char: " << t << "\n";
-  //    }
+  virtual ~xml_oarchive() {
+    if (0 == (m_flags & boost::archive::no_header)) {
+      this->This()->put("</ulib_serialization>\n");
+    }
+  }
 
   using basic_xml_oarchive::save_override;
 
@@ -432,17 +422,14 @@ public:
 #endif
       ::boost::serialization::hrp<T> &t) {
     this->This()->save_start(t.name());
-    //        t.vtos();
-    //        this->detail_common_oarchive::save_override(t.const_value());
+    this->detail_common_oarchive::save_override(t.const_value());
     this->This()->save_end(t.name());
   }
 
   void save_override(const char *str) {
     // Do not save any human decoration string //
-    //        basic_text_oprimitive::save(str);
+    // basic_text_oprimitive::save(str);
   }
-
-  ~xml_oarchive() {}
 };
 
 // typedef boost::archive::detail::polymorphic_oarchive_route<
@@ -467,29 +454,21 @@ public:
   text_iarchive(std::istream &is, unsigned int flags = 0)
       : text_iarchive_impl<Archive>(is, flags) {}
 
-  using basic_text_iarchive::load_override;
+  using base::load_override;
 
   void load_override(boost::archive::object_id_type &t) {}
 
-  // class_name_type can't be handled here as it depends upon the
-  // char type used by the stream.  So require the derived implementation.
-  // derived in this case is xml_iarchive_impl or base ..
-  using base::load_override;
 
   void load_override(const char *str) {
     StringReader sr(basic_text_iprimitive::is);
     sr >> str;
   }
 
-  ~text_iarchive() {};
+  virtual ~text_iarchive() {}
 };
 
 typedef text_iarchive naked_text_iarchive;
 
-// typedef boost::archive::detail::polymorphic_iarchive_route<
-// naked_text_iarchive
-//> polymorphic_text_iarchive;
-
 class text_oarchive : public boost::archive::text_oarchive_impl<text_oarchive> {
   typedef text_oarchive Archive;
   typedef boost::archive::text_oarchive_impl<Archive> base;
@@ -507,13 +486,9 @@ public:
 
   void save_override(const char *str) { basic_text_oprimitive::save(str); }
 
-  ~text_oarchive() {}
+  virtual ~text_oarchive() {}
 };
 
-// typedef boost::archive::detail::polymorphic_oarchive_route<
-// boost::archive::text_oarchive_impl<text_oarchive>
-//> polymorphic_text_oarchive;
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -532,7 +507,7 @@ public:
   hrt_iarchive(std::istream &is, unsigned int flags = 0)
       : base(is, flags | boost::archive::no_header) {}
 
-  using basic_text_iarchive::load_override;
+  using base::load_override;
 
   // hide all archive props //
   void load_override(boost::archive::object_id_type &t) {}
@@ -544,17 +519,13 @@ public:
   void load_override(boost::archive::class_name_type &t) {}
   void load_override(boost::archive::tracking_type &t) {}
 
-  // class_name_type can't be handled here as it depends upon the
-  // char type used by the stream.  So require the derived implementation.
-  // derived in this case is xml_iarchive_impl or base ..
-  using base::load_override;
 
   void load_override(const char *str) {
     StringReader sr(basic_text_iprimitive::is);
     sr >> str;
   }
 
-  ~hrt_iarchive() {};
+  virtual ~hrt_iarchive() {}
 };
 
 class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
@@ -583,7 +554,14 @@ public:
 
   void save_override(const char *str) { basic_text_oprimitive::save(str); }
 
-  ~hrt_oarchive() {}
+  template <class T>
+  void save_override(const boost::serialization::hrp<T> &t) {
+    *this << t.name() << ": ";
+    *this << t.const_value();
+    *this << "\n";
+  }
+
+  virtual ~hrt_oarchive() {}
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -611,22 +589,18 @@ public:
     //        basic_text_oprimitive::save(str);
   }
 
-  template <class T> void save_override(T &t) {
-    base::save_override(boost::serialization::make_nvp(NULL, t));
+  template <class T> void save_override(const T &t) {
+    base::save_override(boost::serialization::make_nvp(nullptr, t));
   }
 
-  // activate this if you want to trap non nvp objects //
-  //    template<class T>
-  //    void save_override(T & t)
-  //    {
-  //        BOOST_MPL_ASSERT((boost::serialization::is_wrapper< T >));
-  //        //        this->detail_common_oarchive::save_override(t);
-  //    }
-
   template <class T> void save_override(const boost::serialization::nvp<T> &t) {
     base::save_override(t);
   }
 
+  template <class T> void save_override(const boost::serialization::hrp<T> &t) {
+    base::save_override(boost::serialization::make_nvp(t.name(), t.const_value()));
+  }
+
   // specific overrides for attributes - not name value pairs so we
   // want to trap them before the above "fall through"
   // since we don't want to see these in the output - make them no-ops.
@@ -643,11 +617,9 @@ public:
   log_archive(std::ostream &os, unsigned int flags = 0)
       : boost::archive::xml_oarchive_impl<log_archive>(
             os, flags | boost::archive::no_header) {}
-};
 
-// typedef boost::archive::detail::polymorphic_oarchive_route<
-// boost::archive::xml_oarchive_impl<log_archive>
-//> polymorphic_log_archive;
+  virtual ~log_archive() {}
+};
 
 } // namespace Archive
 
@@ -661,10 +633,4 @@ ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_iarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_oarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::log_archive)
 
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
-
 #endif // U_CORE_ARCHIVES_H

src/Core/CMakeLists.txt

@@ -10,6 +10,8 @@ set(HEADERS
     Macros.h 
     Mpl.h 
     Object.h 
+    ObjectFactory.h
+    ObjectsContext.h
     Options.h 
     Serializable.h 
     Signal.h 
@@ -17,6 +19,8 @@ set(HEADERS
     SmartPointer.h 
     StaticInterface.h 
     StringReader.h 
+    Threads.h
+    Monitor.h
     Types.h 
     Uuid.h 
     Vector.h
@@ -26,13 +30,20 @@ set(SOURCES
     Archives.cpp 
     Debug.cpp 
     Object.cpp 
+    ObjectFactory.cpp
+    ObjectsContext.cpp
     Options.cpp 
     Serializable.cpp 
     Signal.cpp 
     Uuid.cpp
+    Threads.cpp
 )
 
-set(LIBRARIES Boost::program_options Boost::serialization)
+set(LIBRARIES 
+    Boost::program_options 
+    Boost::serialization
+    OpenMP::OpenMP_CXX
+)
 
 set(libname ${PACKAGE_LIBPREFIX}Core)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -47,6 +58,7 @@ if(USE_CUDA)
 endif()
 
 target_link_libraries(${libname} ${LIBRARIES})
+target_compile_definitions(${libname} PUBLIC ULIB_SERIALIZATION_VERSION="${PROJECT_VERSION}")
 
 install(TARGETS ${libname}
         EXPORT "uLibTargets"

src/Core/DataAllocator.h

@@ -52,6 +52,7 @@ public:
       else
         m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
     }
+    // std::cout << "DataAllocator Constructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
   }
 
   DataAllocator(const DataAllocator<T> &other)
@@ -63,7 +64,12 @@ public:
           m_RamData = new T[m_Size];
         else
           m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
-        std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+        
+        if (m_OwnsObjects) {
+            std::copy(other.m_RamData, other.m_RamData + m_Size, m_RamData);
+        } else {
+            std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+        }
       }
 #ifdef USE_CUDA
       if (other.m_VramData) {
@@ -73,14 +79,17 @@ public:
       }
 #endif
     }
+    // std::cout << "DataAllocator CopyConstructor: from=" << other.m_RamData << " to=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
   }
 
   ~DataAllocator() {
+    // std::cout << "DataAllocator Destructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
     if (m_RamData) {
       if (m_OwnsObjects)
         delete[] m_RamData;
       else
         ::operator delete(m_RamData);
+      m_RamData = nullptr;
     }
 #ifdef USE_CUDA
     if (m_VramData) {
@@ -91,6 +100,13 @@ public:
 
   DataAllocator &operator=(const DataAllocator &other) {
     if (this != &other) {
+      if (m_Size == other.m_Size && m_OwnsObjects != other.m_OwnsObjects) {
+          // Ownership changed but size is same: we must force reallocation
+          // to avoid using the wrong delete operator later.
+          size_t oldSize = m_Size;
+          m_Size = 0; 
+          resize(oldSize); // This will free the old buffer with the OLD ownership
+      }
       m_OwnsObjects = other.m_OwnsObjects;
       resize(other.m_Size);
       m_Device = other.m_Device;
@@ -101,7 +117,11 @@ public:
           else
             m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
         }
-        std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+        if (m_OwnsObjects) {
+            std::copy(other.m_RamData, other.m_RamData + m_Size, m_RamData);
+        } else {
+            std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+        }
       }
 #ifdef USE_CUDA
       if (other.m_VramData) {
@@ -112,6 +132,7 @@ public:
       }
 #endif
     }
+    // std::cout << "DataAllocator AssigmentOp: otherPtr=" << other.m_RamData << " thisPtr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
     return *this;
   }
 
@@ -152,6 +173,8 @@ public:
     if (m_Size == size)
       return;
 
+    // std::cout << "DataAllocator Resize: from=" << m_Size << " to=" << size << " ptr=" << m_RamData << " own=" << m_OwnsObjects << std::endl;
+
     T *newRam = nullptr;
     T *newVram = nullptr;
 
@@ -162,7 +185,11 @@ public:
         newRam = static_cast<T *>(::operator new(size * sizeof(T)));
 
       if (m_RamData) {
-        std::memcpy(newRam, m_RamData, std::min(m_Size, size) * sizeof(T));
+        if (m_OwnsObjects) {
+            std::copy(m_RamData, m_RamData + std::min(m_Size, size), newRam);
+        } else {
+            std::memcpy(newRam, m_RamData, std::min(m_Size, size) * sizeof(T));
+        }
       }
 
 #ifdef USE_CUDA

src/Core/Debug.h

@@ -36,7 +36,77 @@
 #include "SmartPointer.h"
 
 #include <boost/any.hpp>
-#include <TObject.h>
+
+
+
+/**
+ * @file Debug.h
+ * @brief Unified Debugging and Monitoring System for uLib.
+ *
+ * # Debug System Documentation
+ *
+ * The `Debug` system provides a flexible, adapter-based mechanism for monitoring
+ * and outputting internal variables and states without hardcoding output logic
+ * into core classes. 
+ *
+ * ## Architecture
+ * 
+ * The system follows an adapter pattern:
+ * 
+ * - **`DebugAdapterInterface`**: The base interface for all output targets. 
+ *   Subclasses define how primitive types and strings are handled (e.g., printing 
+ *   to `std::cout`, writing to a log file, or updating a real-time UI widget).
+ *
+ * - **`Debug` Class**: The central registry. It stores:
+ *   1.  A list of "Adapters" (`DebugAdapterInterface`).
+ *   2.  A list of "Items" to monitor. Each item is a reference to a variable 
+ *       associated with a name.
+ *
+ * - **Type Safety**: Although variables are stored using `boost::any` (type erasure), 
+ *   the system automatically preserves the original type information via 
+ *   internal template adapters (`AnyCastAdapter`), ensuring that the correct 
+ *   overload of the adapter interface is called.
+ *
+ * ## Core Components
+ * 
+ * | Component | Description |
+ * | :--- | :--- |
+ * | `Debug` | The main controller used to add adapters and register variables. |
+ * | `DebugAdapterInterface` | Virtual base for creating new output methods. |
+ * | `DebugAdapterText` | A simple built-in adapter for `std::ostream` output. |
+ *
+ * ## How to Use
+ *
+ * ### 1. Initialize the Debug Object
+ * ```cpp
+ * uLib::Debug dbg;
+ * ```
+ *
+ * ### 2. Add an Adapter
+ * ```cpp
+ * uLib::DebugAdapterText console(std::cout);
+ * dbg.AddAdapter(console);
+ * ```
+ *
+ * ### 3. Register Variables to Monitor
+ * Use the `operator()` to bind a variable by reference.
+ * ```cpp
+ * int frameCount = 0;
+ * std::string state = "Initializing";
+ * dbg("Frames", frameCount);
+ * dbg("Status", state);
+ * ```
+ *
+ * ### 4. Update
+ * Call `Update()` periodically (e.g., once per frame) to push the current 
+ * values of all registered variables to all connected adapters.
+ * ```cpp
+ * while(running) {
+ *    frameCount++;
+ *    dbg.Update(); // This triggers the output
+ * }
+ * ```
+ */
 
 namespace uLib {
 
@@ -107,7 +177,6 @@ public:
 
 
 
-
 class Debug {
     typedef detail::DebugAdapterInterface AdapterInterface;
     typedef SmartPointer<detail::DebugAdapterInterface> Adapter;

src/Core/Monitor.h

@@ -0,0 +1,215 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CORE_MONITOR_H
+#define U_CORE_MONITOR_H
+
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
+#include <utility>
+
+namespace uLib {
+
+/**
+ * @brief Mutex class wraps std::timed_mutex and is used for thread synchronization.
+ */
+class Mutex {
+public:
+  Mutex() = default;
+  ~Mutex() = default;
+
+  /** @brief Locks the mutex, blocking if necessary. */
+  void Lock() { m_Mutex.lock(); }
+
+  /** @brief Unlocks the mutex. */
+  void Unlock() { m_Mutex.unlock(); }
+
+  /** @brief Tries to lock the mutex without blocking. */
+  bool TryLock() { return m_Mutex.try_lock(); }
+
+  /** @brief Tries to lock the mutex within a timeout in milliseconds. */
+  bool TryLockFor(int timeout_ms) {
+      if (timeout_ms < 0) { Lock(); return true; }
+      return m_Mutex.try_lock_for(std::chrono::milliseconds(timeout_ms));
+  }
+
+  /** @brief RAII helper for scoped locking. */
+  class ScopedLock {
+  public:
+    ScopedLock(Mutex &mutex) : m_Mutex(mutex) { m_Mutex.Lock(); }
+    ~ScopedLock() { m_Mutex.Unlock(); }
+  private:
+    Mutex &m_Mutex;
+    // Non-copyable
+    ScopedLock(const ScopedLock&) = delete;
+    ScopedLock& operator=(const ScopedLock&) = delete;
+  };
+
+  /** @brief Returns the underlying std::timed_mutex. */
+  std::timed_mutex& GetNative() { return m_Mutex; }
+
+private:
+  std::timed_mutex m_Mutex;
+  // Non-copyable
+  Mutex(const Mutex &) = delete;
+  Mutex &operator=(const Mutex &) = delete;
+};
+
+namespace detail {
+
+/** @brief Internal implementation for the ULIB_MUTEX_LOCK macros. */
+class ScopedTimedLock {
+public:
+    ScopedTimedLock(Mutex& mutex, int timeout_ms) 
+        : m_RawMutex(nullptr), m_MutexWrapper(&mutex), m_Locked(false) {
+        m_Locked = m_MutexWrapper->TryLockFor(timeout_ms);
+    }
+    
+    ScopedTimedLock(std::timed_mutex& mutex, int timeout_ms) 
+        : m_RawMutex(&mutex), m_MutexWrapper(nullptr), m_Locked(false) {
+        if (timeout_ms < 0) { m_RawMutex->lock(); m_Locked = true; }
+        else m_Locked = m_RawMutex->try_lock_for(std::chrono::milliseconds(timeout_ms));
+    }
+
+    ~ScopedTimedLock() {
+        if (m_Locked) {
+            if (m_RawMutex) m_RawMutex->unlock();
+            else if (m_MutexWrapper) m_MutexWrapper->Unlock();
+        }
+    }
+    
+    operator bool() const { return m_Locked; }
+    void unlock() { if (m_Locked) { 
+        if (m_RawMutex) m_RawMutex->unlock();
+        else if (m_MutexWrapper) m_MutexWrapper->Unlock();
+        m_Locked = false; 
+    } }
+
+private:
+    std::timed_mutex* m_RawMutex = nullptr;
+    Mutex* m_MutexWrapper = nullptr;
+    bool m_Locked;
+    
+    // Non-copyable/movable to be safe in the 'for' loop
+    ScopedTimedLock(const ScopedTimedLock&) = delete;
+    ScopedTimedLock& operator=(const ScopedTimedLock&) = delete;
+    ScopedTimedLock(ScopedTimedLock&&) = default; 
+};
+
+inline ScopedTimedLock makeScopedMutexLock(Mutex& mutex, int timeout_ms) {
+    return ScopedTimedLock(mutex, timeout_ms);
+}
+
+inline ScopedTimedLock makeScopedMutexLock(std::timed_mutex& mutex, int timeout_ms) {
+    return ScopedTimedLock(mutex, timeout_ms);
+}
+
+} // namespace detail
+
+/**
+ * @brief Macro for block-scoped locking of a static mutex.
+ * @param timeout Timeout in ms (-1 for infinite).
+ */
+#define ULIB_STATIC_LOCK(timeout) \
+    static std::timed_mutex __ulib_static_mutex; \
+    for (auto __ulib_lock = uLib::detail::makeScopedMutexLock(__ulib_static_mutex, timeout); \
+         __ulib_lock; \
+         __ulib_lock.unlock())
+
+/**
+ * @brief Macro for block-scoped locking of a provided mutex.
+ * @param mutex The uLib::Mutex or std::timed_mutex to lock.
+ * @param timeout Timeout in ms (-1 for infinite).
+ */
+#define ULIB_MUTEX_LOCK(mutex, timeout) \
+    for (auto __ulib_lock = uLib::detail::makeScopedMutexLock(mutex, timeout); \
+         __ulib_lock; \
+         __ulib_lock.unlock())
+
+/**
+ * @brief RecursiveMutex class wraps std::recursive_timed_mutex.
+ */
+class RecursiveMutex {
+public:
+  RecursiveMutex() = default;
+  ~RecursiveMutex() = default;
+
+  /** @brief Locks the mutex, blocking if necessary. */
+  void Lock() { m_Mutex.lock(); }
+
+  /** @brief Unlocks the mutex. */
+  void Unlock() { m_Mutex.unlock(); }
+
+  /** @brief Tries to lock the mutex without blocking. */
+  bool TryLock() { return m_Mutex.try_lock(); }
+
+  /** @brief Tries to lock the mutex within a timeout in milliseconds. */
+  bool TryLockFor(int timeout_ms) {
+      if (timeout_ms < 0) { Lock(); return true; }
+      return m_Mutex.try_lock_for(std::chrono::milliseconds(timeout_ms));
+  }
+
+  /** @brief RAII helper for scoped locking. */
+  class ScopedLock {
+  public:
+    ScopedLock(RecursiveMutex &mutex) : m_Mutex(mutex) { m_Mutex.Lock(); }
+    ~ScopedLock() { m_Mutex.Unlock(); }
+  private:
+    RecursiveMutex &m_Mutex;
+    ScopedLock(const ScopedLock&) = delete;
+    ScopedLock& operator=(const ScopedLock&) = delete;
+  };
+
+private:
+  std::recursive_timed_mutex m_Mutex;
+  RecursiveMutex(const RecursiveMutex &) = delete;
+  RecursiveMutex &operator=(const RecursiveMutex &) = delete;
+};
+
+/**
+ * @brief Monitor class provides a base for objects that need thread-safe access.
+ */
+template <typename T>
+class Monitor {
+protected:
+  T* m_Resource;
+  Mutex m_Mutex;
+
+public:
+  Monitor(T* resource) : m_Resource(resource) {}
+  virtual ~Monitor() { delete m_Resource; }
+
+  /** @brief Thread-safe access to the resource through a lambda. */
+  template <typename F>
+  auto Access(F f) -> decltype(f(*m_Resource)) {
+    Mutex::ScopedLock lock(m_Mutex);
+    return f(*m_Resource);
+  }
+};
+
+} // namespace uLib
+
+#endif // U_CORE_MONITOR_H

src/Core/Object.cpp

@@ -35,6 +35,9 @@
 #include "boost/archive/polymorphic_xml_iarchive.hpp"
 #include "boost/archive/polymorphic_xml_oarchive.hpp"
 
+#include <vector>
+#include "Property.h"
+
 namespace uLib {
 
 const char *Version::PackageName = PACKAGE_NAME;
@@ -56,26 +59,118 @@ public:
     GenericMFPtr sloptr;
     std::string slostr;
   };
-
-  Vector<Signal> sigv;
-  Vector<Slot> slov;
+  
+  std::string m_InstanceName;
+  std::vector<Signal> sigv;
+  std::vector<Slot> slov;
+  std::vector<PropertyBase*> m_Properties;
+  std::vector<PropertyBase*> m_DynamicProperties;
+  bool m_SignalsBlocked;
 };
 
+// Implementations of Property methods
+void Object::RegisterProperty(PropertyBase* prop) {
+    if (prop) {
+        d->m_Properties.push_back(prop);
+    }
+}
+
+void Object::RegisterDynamicProperty(PropertyBase* prop) {
+    if (prop) {
+        for (auto* existing : d->m_DynamicProperties) {
+            if (existing == prop) return;
+            if (existing->GetQualifiedName() == prop->GetQualifiedName()) return;
+        }
+        d->m_DynamicProperties.push_back(prop);
+    }
+}
+
+const std::vector<PropertyBase*>& Object::GetProperties() const {
+    return d->m_Properties;
+}
+
+PropertyBase* Object::GetProperty(const std::string& name) const {
+    for (auto* p : d->m_Properties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
+    for (auto* p : d->m_DynamicProperties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
+    return nullptr;
+}
+
+void Object::NotifyPropertiesUpdated() {
+    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) {}
+
+// Explicitly instantiate for all uLib archives
+template void Object::serialize(Archive::xml_oarchive &, const unsigned int);
+template void Object::serialize(Archive::xml_iarchive &, const unsigned int);
+template void Object::serialize(Archive::text_oarchive &, const unsigned int);
+template void Object::serialize(Archive::text_iarchive &, const unsigned int);
+template void Object::serialize(Archive::hrt_oarchive &, const unsigned int);
+template void Object::serialize(Archive::hrt_iarchive &, const unsigned int);
+template void Object::serialize(Archive::log_archive &, const unsigned int);
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // OBJECT IMPLEMENTATION
 
-Object::Object() : d(new ObjectPrivate) {}
+Object::Object() : d(new ObjectPrivate) {
+    d->m_SignalsBlocked = false;
+}
+Object::Object(const Object &copy) : d(new ObjectPrivate) {
+    if (copy.d) {
+        d->m_InstanceName = copy.d->m_InstanceName;
+        d->m_SignalsBlocked = copy.d->m_SignalsBlocked;
+    }
+}
 
-Object::Object(const Object &copy) : d(new ObjectPrivate(*copy.d)) {}
+Object& Object::operator=(const Object &other) {
+    // Intentionally does NOT share 'd'. Each Object owns its own ObjectPrivate.
+    // Without this, the compiler-generated operator= would copy the 'd' pointer,
+    // causing two objects to share the same ObjectPrivate. When both are
+    // destroyed, 'd' would be deleted twice, corrupting the heap.
+    if (this != &other && other.d) {
+        d->m_InstanceName = other.d->m_InstanceName;
+        d->m_SignalsBlocked = other.d->m_SignalsBlocked;
+    }
+    return *this;
+}
 
-Object::~Object() { delete d; }
+Object::~Object() {
+    for (auto* p : d->m_DynamicProperties) {
+        delete p;
+    }
+    delete d;
+}
 
 void Object::DeepCopy(const Object &copy) {
-  // should lock to be tread safe //
-  memcpy(d, copy.d, sizeof(ObjectPrivate));
-  // ERROR! does not copy parameters ... <<<< FIXXXXX
+    if (this == &copy) return;
+    if (copy.d) d->m_InstanceName = copy.d->m_InstanceName;
+    std::cout << "Object DeepCopy: from d=" << copy.d << " to d=" << d << std::endl;
+    // Note: signals, slots and properties are intentionally not copied 
+    // to maintain instance uniquely and avoid duplicate registrations.
+    this->Updated();
 }
 
 void Object::SaveXml(std::ostream &os, Object &ob) {
@@ -99,9 +194,8 @@ void Object::LoadConfig(std::istream &is, int version) {
 
 void Object::PrintSelf(std::ostream &o) const {
   o << "OBJECT signals: ------------------\n";
-  Vector<ObjectPrivate::Signal>::Iterator itr;
-  for (itr = d->sigv.begin(); itr < d->sigv.end(); itr++) {
-    o << "  signal:[ " << itr->sigstr << " ]\n";
+  for (const auto& sig : d->sigv) {
+    o << "  signal:[ " << sig.sigstr << " ]\n";
   }
   o << "--------------------------------------\n\n";
 }
@@ -145,7 +239,24 @@ GenericMFPtr *Object::findSlotImpl(const char *name) const {
   return NULL;
 }
 
-void Object::Updated() { ULIB_SIGNAL_EMIT(Object::Updated); }
+const std::string& Object::GetInstanceName() const {
+  return d->m_InstanceName;
+}
+
+void Object::SetInstanceName(const std::string& name) {
+  d->m_InstanceName = name;
+  this->Updated();
+}
+ 
+bool Object::blockSignals(bool block) {
+  bool old = d->m_SignalsBlocked;
+  d->m_SignalsBlocked = block;
+  return old;
+}
+ 
+bool Object::signalsBlocked() const {
+  return d->m_SignalsBlocked;
+}
 
 // std::ostream &
 // operator << (std::ostream &os, uLib::Object &ob)

src/Core/Object.h

@@ -27,6 +27,7 @@
 #define U_CORE_OBJECT_H
 
 #include <iostream>
+#include <string>
 
 // WARNING: COPILE ERROR if this goes after mpl/vector //
 // #include "Core/Vector.h"
@@ -50,6 +51,9 @@ class polymorphic_oarchive;
 
 namespace uLib {
 
+class PropertyBase;
+class ObjectsContext;
+
 class Version {
 public:
   static const char *PackageName;
@@ -72,7 +76,29 @@ public:
 
   Object();
   Object(const Object &copy);
-  ~Object();
+  virtual ~Object();
+
+  virtual const char * GetClassName() const { return type_name(); }
+  virtual const char * type_name() const { return "Object"; }
+
+  const std::string& GetInstanceName() const;
+  void SetInstanceName(const std::string& name);
+  
+  /** @brief Temporarily blocks all signal emissions from this object. Returns previous state. */
+  bool blockSignals(bool block);
+  
+  /** @brief Checks if signals are currently blocked. */
+  bool signalsBlocked() const;
+
+  ////////////////////////////////////////////////////////////////////////////
+  // PROPERTIES //
+  void RegisterProperty(PropertyBase* prop);
+  void RegisterDynamicProperty(PropertyBase* prop);
+  const std::vector<PropertyBase*>& GetProperties() 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. */
+  void NotifyPropertiesUpdated();
 
   ////////////////////////////////////////////////////////////////////////////
   // PARAMETERS //
@@ -80,13 +106,25 @@ public:
   // FIXX !!!
   virtual void DeepCopy(const Object &copy);
 
+  /** @brief Returns a nested context for children objects, if any. */
+  virtual ObjectsContext* GetChildren() { return nullptr; }
+
   ////////////////////////////////////////////////////////////////////////////
   // SERIALIZATION //
 
   template <class ArchiveT>
-  void serialize(ArchiveT &ar, const unsigned int version) {}
+  void serialize(ArchiveT &ar, const unsigned int version);
+
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) {}
+  virtual void serialize(Archive::text_oarchive & 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);
@@ -99,6 +137,7 @@ public:
 
   signals:
   virtual void Updated();
+  virtual void PropertyUpdated();
 
   // Qt4 style connector //
   static bool connect(const Object *ob1, const char *signal_name,
@@ -115,24 +154,22 @@ public:
 
   // Qt5 style connector //
   template <typename Func1, typename Func2>
-  static bool
+  static Connection
   connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
           typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
     SignalBase *sigb = sender->findOrAddSignal(sigf);
-    ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(sigb, slof,
+    return ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(sigb, slof,
                                                                     receiver);
-    return true;
   }
 
   // Lambda/Function object connector //
   template <typename Func1, typename SlotT>
-  static bool connect(typename FunctionPointer<Func1>::Object *sender,
+  static Connection connect(typename FunctionPointer<Func1>::Object *sender,
                       Func1 sigf, SlotT slof) {
     SignalBase *sigb = sender->findOrAddSignal(sigf);
     typedef typename FunctionPointer<Func1>::SignalSignature SigSignature;
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(slof);
-    return true;
+    return reinterpret_cast<SigT *>(sigb)->connect(slof);
   }
 
   template <typename Func1, typename Func2>
@@ -144,10 +181,9 @@ public:
   }
 
   template <typename FuncT>
-  static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
-    ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(sigb, slof,
+  static inline Connection connect(SignalBase *sigb, FuncT slof, Object *receiver) {
+    return ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(sigb, slof,
                                                                     receiver);
-    return true;
   }
 
   template <typename FuncT>
@@ -201,10 +237,7 @@ public:
 
   void PrintSelf(std::ostream &o) const;
 
-  inline const Object &operator=(const Object &copy) {
-    this->DeepCopy(copy);
-    return *this;
-  }
+  Object &operator=(const Object &other);
 
 private:
   bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);

src/Core/ObjectFactory.cpp

@@ -0,0 +1,32 @@
+#include "ObjectFactory.h"
+
+namespace uLib {
+
+ObjectFactory& ObjectFactory::Instance() {
+    static ObjectFactory instance;
+    return instance;
+}
+
+void ObjectFactory::Register(const std::string& className, FactoryFunction func) {
+    if (m_factoryMap.find(className) == m_factoryMap.end()) {
+        m_factoryMap[className] = func;
+    }
+}
+
+Object* ObjectFactory::Create(const std::string& className) {
+    auto it = m_factoryMap.find(className);
+    if (it != m_factoryMap.end()) {
+        return (it->second)();
+    }
+    return nullptr;
+}
+
+std::vector<std::string> ObjectFactory::GetRegisteredClasses() const {
+    std::vector<std::string> classes;
+    for (auto const& [name, func] : m_factoryMap) {
+        classes.push_back(name);
+    }
+    return classes;
+}
+
+} // namespace uLib

src/Core/ObjectFactory.h

@@ -0,0 +1,68 @@
+#ifndef U_CORE_OBJECTFACTORY_H
+#define U_CORE_OBJECTFACTORY_H
+
+#include <string>
+#include <map>
+#include <vector>
+#include <functional>
+#include "Core/Object.h"
+
+namespace uLib {
+
+/**
+ * @brief Singleton factory for dynamic Object instantiation based on class name.
+ */
+class ObjectFactory {
+public:
+    typedef std::function<Object*()> FactoryFunction;
+
+    /** @brief Get the singleton instance. */
+    static ObjectFactory& Instance();
+
+    /** @brief Register a factory function for a given class name. */
+    void Register(const std::string& className, FactoryFunction func);
+
+    /** @brief Create a new instance of the specified class. */
+    Object* Create(const std::string& className);
+
+    /** @brief Get the names of all registered classes. */
+    std::vector<std::string> GetRegisteredClasses() const;
+
+private:
+    ObjectFactory() = default;
+    ~ObjectFactory() = default;
+
+    // Prevent copy and assignment
+    ObjectFactory(const ObjectFactory&) = delete;
+    ObjectFactory& operator=(const ObjectFactory&) = delete;
+
+    std::map<std::string, FactoryFunction> m_factoryMap;
+};
+
+/**
+ * @brief Helper class to statically register a factory function.
+ */
+template <typename T>
+class ObjectRegistrar {
+public:
+    ObjectRegistrar(const std::string& className) {
+        ObjectFactory::Instance().Register(className, []() -> Object* { return new T(); });
+    }
+};
+
+#define ULIB_REG_CONCAT_IMPL(a, b) a##b
+#define ULIB_REG_CONCAT(a, b) ULIB_REG_CONCAT_IMPL(a, b)
+
+/**
+ * @brief Macro to register a class to the factory.
+ * 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);
+
+#define ULIB_REGISTER_OBJECT_NAME(className, registeredName) \
+    static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(g_ObjectRegistrar_, __LINE__)(registeredName);
+
+} // namespace uLib
+
+#endif // U_CORE_OBJECTFACTORY_H

src/Core/ObjectsContext.cpp

@@ -0,0 +1,63 @@
+#include "Core/ObjectsContext.h"
+#include <algorithm>
+
+namespace uLib {
+
+ObjectsContext::ObjectsContext() : Object() {}
+
+ObjectsContext::~ObjectsContext() {}
+
+void ObjectsContext::AddObject(Object* obj) {
+    if (obj && std::find(m_objects.begin(), m_objects.end(), obj) == m_objects.end()) {
+        m_objects.push_back(obj);
+        // Connect child's update to context's update to trigger re-renders
+        Object::connect(obj, &Object::Updated, this, &Object::Updated);
+        ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+        this->Updated(); // Signal that the context has been updated
+    }
+}
+
+void ObjectsContext::RemoveObject(Object* obj) {
+    auto it = std::find(m_objects.begin(), m_objects.end(), obj);
+    if (it != m_objects.end()) {
+        Object* removedObj = *it;
+        m_objects.erase(it);
+        ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, removedObj);
+        this->Updated(); // Signal that the context has been updated
+    }
+}
+
+void ObjectsContext::Clear() {
+    if (!m_objects.empty()) {
+        for (auto obj : m_objects) {
+            ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
+        }
+        m_objects.clear();
+        this->Updated();
+    }
+}
+
+const std::vector<Object*>& ObjectsContext::GetObjects() const {
+    return m_objects;
+}
+
+size_t ObjectsContext::GetCount() const {
+    return m_objects.size();
+}
+
+Object* ObjectsContext::GetObject(size_t index) const {
+    if (index < m_objects.size()) {
+        return m_objects[index];
+    }
+    return nullptr;
+}
+
+void ObjectsContext::ObjectAdded(Object* obj) {
+    ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+}
+
+void ObjectsContext::ObjectRemoved(Object* obj) {
+    ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
+}
+
+} // namespace uLib

src/Core/ObjectsContext.h

@@ -0,0 +1,68 @@
+#ifndef U_CORE_OBJECTS_CONTEXT_H
+#define U_CORE_OBJECTS_CONTEXT_H
+
+#include "Core/Object.h"
+#include <vector>
+
+namespace uLib {
+
+/**
+ * @brief ObjectsContext represents a collection of Object instances.
+ */
+class ObjectsContext : virtual public Object {
+public:
+    ObjectsContext();
+    virtual ~ObjectsContext();
+
+    uLibTypeMacro(ObjectsContext, Object)
+    virtual ObjectsContext* GetChildren() override { return this; }
+
+    /**
+     * @brief Adds an object to the context.
+     * @param obj Pointer to the object to add.
+     */
+    virtual void AddObject(Object* obj);
+
+    /**
+     * @brief Removes an object from the context.
+     * @param obj Pointer to the object to remove.
+     */
+    virtual void RemoveObject(Object* obj);
+
+    /**
+     * @brief Clears all objects from the context.
+     */
+    void Clear();
+
+    /**
+     * @brief Returns the collection of objects.
+     * @return Const reference to the vector of object pointers.
+     */
+    const std::vector<Object*>& GetObjects() const;
+    
+    signals:
+    /** @brief Signal emitted when an object is added. */
+    virtual void ObjectAdded(Object* obj);
+    /** @brief Signal emitted when an object is removed. */
+    virtual void ObjectRemoved(Object* obj);
+
+    /**
+     * @brief Returns the number of objects in the context.
+     * @return Size of the collection.
+     */
+    size_t GetCount() const;
+
+    /**
+     * @brief Returns an object by index.
+     * @param index The index of the object.
+     * @return Pointer to the object or nullptr if index is out of bounds.
+     */
+    Object* GetObject(size_t index) const;
+
+private:
+    std::vector<Object*> m_objects;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_OBJECTS_CONTEXT_H

src/Core/Property.h

@@ -0,0 +1,439 @@
+#ifndef U_CORE_PROPERTY_H
+#define U_CORE_PROPERTY_H
+
+#include <string>
+#include <vector>
+#include <sstream>
+#include <typeinfo>
+#include <typeindex> // Added
+#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 "Core/Archives.h"
+#include "Core/Signal.h"
+#include "Core/Object.h"
+
+namespace uLib {
+
+/**
+ * @brief Base class for properties to allow runtime listing and identification.
+ */
+class PropertyBase : public Object {
+public:
+  virtual ~PropertyBase() {}
+  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 const std::string& GetUnits() const = 0;
+  virtual void SetUnits(const std::string& units) = 0;
+  virtual const std::vector<std::string>& GetEnumLabels() const {
+      static std::vector<std::string> empty;
+      return empty;
+  }
+  virtual const std::string& GetGroup() const = 0;
+  virtual void SetGroup(const std::string& group) = 0;
+
+  virtual bool HasRange() const { return false; }
+  virtual double GetMin() const { return 0; }
+  virtual double GetMax() const { return 0; }
+  virtual bool HasDefault() const { return false; }
+  virtual std::string GetDefaultValueAsString() const { return ""; }
+  virtual bool IsReadOnly() const = 0;
+
+  std::string GetQualifiedName() const {
+      if (GetGroup().empty()) return GetName();
+      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;
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) override = 0;
+  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;
+};
+
+
+
+
+
+
+
+
+/**
+ * @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) {
+          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) {
+          m_owner->RegisterProperty(this);
+      }
+  }
+
+  virtual ~Property() {
+      if (m_own) delete m_value;
+  }
+
+  // Identification
+  virtual const std::string& GetName() const override { return m_name; }
+  virtual const char* GetTypeName() const override { return typeid(T).name(); }
+  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(T)); }
+  virtual const std::string& GetUnits() const override { return m_units; }
+  virtual void SetUnits(const std::string& units) override { m_units = units; }
+  virtual const std::string& GetGroup() const override { return m_group; }
+  virtual void SetGroup(const std::string& group) override { m_group = group; }
+
+  
+  std::string GetValueAsString() const override {
+      try {
+          return boost::lexical_cast<std::string>(*m_value);
+      } 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) {
+    T val = value;
+    ValidateT<T>(val);
+    if (*m_value != val) {
+      *m_value = val;
+      ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
+      this->Updated();
+      if (m_owner) m_owner->Updated();
+    }
+  }
+
+  void SetRange(const T& min, const T& max) { m_Min = min; m_Max = max; m_HasRange = true; }
+  void SetDefault(const T& def) { m_Default = def; m_HasDefault = true; }
+  void SetReadOnly(bool ro) { m_ReadOnly = ro; }
+
+  virtual bool IsReadOnly() const override { return m_ReadOnly; }
+
+  virtual bool HasRange() const override { return m_HasRange; }
+
+  template<typename U = T>
+  typename std::enable_if<std::is_arithmetic<U>::value, double>::type
+  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); } 
+      catch (...) { return ""; }
+  }
+
+  // Operators for seamless usage
+  operator const T&() const { return *m_value; }
+  Property& operator=(const T& value) {
+    Set(value);
+    return *this;
+  }
+
+  // Signals
+  signals:
+  virtual void PropertyChanged() { ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged); }
+
+  // Serialization
+  template <class ArchiveT>
+  void serialize_impl(ArchiveT & ar, const unsigned int version) {
+    ar & boost::serialization::make_nvp(m_name.c_str(), *m_value);
+  }
+
+  void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+  void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_impl(ar, v); }
+
+  virtual void Updated() override {
+      PropertyBase::Updated();
+      this->PropertyChanged();
+  }
+
+private:
+  std::string m_name;
+  std::string m_units;
+  std::string m_group;
+  T* m_value;
+  bool m_own;
+  Object* m_owner;
+  bool m_HasRange;
+  T m_Min;
+  T m_Max;
+  bool m_HasDefault;
+  T m_Default;
+  bool m_ReadOnly;
+};
+
+/**
+ * @brief Conveninent typedefs for common property types.
+ */
+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:
+  EnumProperty(Object* owner, const std::string& name, int* valuePtr, const std::vector<std::string>& labels, const std::string& units = "", const std::string& group = "")
+    : Property<int>(owner, name, valuePtr, units, group), m_Labels(labels) {}
+
+  const std::vector<std::string>& GetEnumLabels() const override { return m_Labels; }
+  const char* GetTypeName() const override { return "Enum"; }
+  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(EnumProperty)); }
+
+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 {
+namespace archive {
+namespace detail {
+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;
+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;
+
+    property_register_archive(Object* obj) : 
+        boost::archive::detail::common_oarchive<property_register_archive>(boost::archive::no_header),
+        m_Object(obj) {}
+    
+    std::string GetCurrentGroup() const {
+        std::string group;
+        for (const auto& g : m_GroupStack) {
+            if (!group.empty()) group += ".";
+            group += g;
+        }
+        return group;
+    }
+
+    // Core logic: encounter HRP -> Create Dynamic Property
+    template<class T>
+    void save_override(const boost::serialization::hrp<T> &t) {
+        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());
+            if (t.has_default()) p->SetDefault(t.default_val());
+            p->SetReadOnly(t.is_read_only());
+            m_Object->RegisterDynamicProperty(p);
+        }
+    }
+
+    template<class T>
+    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.
+            // But here we are registering properties from HRP wrappers.
+            // If it's hrp_val, it means it's an rvalue from a getter. 
+            // The hrp_val wrapper itself owns the value.
+            // However, the property_register_archive is temporary.
+            // This is a bit tricky. Usually HRP(rvalue) is meant for read-only display.
+            // Let's use the address of the value in the wrapper, but mark it read-only.
+            Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp_val<T>&>(t).value(), t.units() ? t.units() : "", GetCurrentGroup());
+            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>
+    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);
+        }
+    }
+
+    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);
+        }
+    }
+
+    // Handle standard NVPs by recursing (important for base classes)
+    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
+    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);
+    }
+
+    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) {}
+    void save_override(const boost::archive::class_id_type & t) {}
+    void save_override(const boost::archive::class_id_optional_type & t) {}
+    void save_override(const boost::archive::class_id_reference_type & t) {}
+    void save_override(const boost::archive::class_name_type & t) {}
+    void save_override(const boost::archive::tracking_type & t) {}
+
+private:
+    std::vector<std::string> m_GroupStack;
+};
+
+
+
+/**
+ * @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 { \
+        _PropActivator(SelfType* self) { \
+            uLib::Archive::property_register_archive _ar(self); \
+            _ar & *self; \
+        } \
+    } _prop_activator{this};
+
+} // namespace Archive
+} // namespace uLib
+
+#endif // U_CORE_PROPERTY_H

src/Core/Serializable.h

@@ -71,44 +71,205 @@ namespace serialization {
 // ACCESS 2 //
 template <class T> struct access2 {};
 
-// NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
-template <class T> class hrp : public wrapper_traits<const hrp<T>> {
+template <class T>
+class hrp : public boost::serialization::wrapper_traits<hrp<T>> {
+  
   const char *m_name;
-  T *m_value;
-  std::string *m_str;
+  const char *m_units;
+  T &m_value;
+  
+  bool m_has_range;
+  T m_min, m_max;
+
+  bool m_has_default;
+  T m_default;
 
 public:
-  explicit hrp(const char *name_, T &t)
-      : m_str(new std::string), m_name(name_), m_value(&t) {}
+  explicit hrp(const char *name_, T &t, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_has_range(false), m_has_default(false) {}
+
+  hrp& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
+  hrp& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
 
   const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const T &const_value() const { return this->m_value; }
+
+  bool has_range() const { return m_has_range; }
+  const T& min_val() const { return m_min; }
+  const T& max_val() const { return m_max; }
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return false; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
 
   template <class Archivex>
-  void save(Archivex &ar, const unsigned int /* file_version */) const {
-    ////        ar.operator<<(const_value());
-    //        std::stringstream ss;
-    //        uLib::Archive::hrt_oarchive har(ss);
-    //        har << make_nvp(m_name,*m_value);
-    //        //        (*m_str) = ss.str();
-    ////        ar.operator << (make_nvp(m_name, ss.str());
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
   }
+
   template <class Archivex>
-  void load(Archivex &ar, const unsigned int /* file_version */) {
-    //        ar.operator>>(value());
+  void load(Archivex &ar, const unsigned int /* version */) {
+    ar >> boost::serialization::make_nvp(m_name, m_value);
   }
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
 };
 
 template <class T>
-inline
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    const
-#endif
-    hrp<T> make_hrp(const char *name, T &t) {
-  return hrp<T>(name, t);
+class hrp_enum : public boost::serialization::wrapper_traits<hrp_enum<T>> {
+  const char *m_name;
+  const char *m_units;
+  T &m_value;
+  std::vector<std::string> m_labels;
+  bool m_has_default;
+  T m_default;
+
+public:
+  explicit hrp_enum(const char *name_, T &t, const std::vector<std::string>& labels, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_labels(labels), m_has_default(false) {}
+
+  hrp_enum& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const std::vector<std::string>& labels() const { return m_labels; }
+
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return false; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
+  }
+
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    ar >> boost::serialization::make_nvp(m_name, m_value);
+  }
+};
+
+template <class T>
+class hrp_val : public boost::serialization::wrapper_traits<hrp_val<T>> {
+  const char *m_name;
+  const char *m_units;
+  T m_value;
+  bool m_has_range;
+  T m_min, m_max;
+  bool m_has_default;
+  T m_default;
+  
+public:
+  explicit hrp_val(const char *name_, T t, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_has_range(false), m_has_default(false) {}
+
+  hrp_val& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
+  hrp_val& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const T &const_value() const { return this->m_value; }
+
+  bool has_range() const { return m_has_range; }
+  const T& min_val() const { return m_min; }
+  const T& max_val() const { return m_max; }
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return true; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
+  }
+
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    // Only for output archives
+  }
+};
+
+template <class T>
+class hrp_enum_val : public boost::serialization::wrapper_traits<hrp_enum_val<T>> {
+  const char *m_name;
+  const char *m_units;
+  T m_value;
+  std::vector<std::string> m_labels;
+  bool m_has_default;
+  T m_default;
+
+public:
+  explicit hrp_enum_val(const char *name_, T t, const std::vector<std::string>& labels, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_labels(labels), m_has_default(false) {}
+
+  hrp_enum_val& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const std::vector<std::string>& labels() const { return m_labels; }
+
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return true; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
+  }
+
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    // Only for output archives
+  }
+};
+
+template <class T>
+inline hrp<T> make_hrp(const char *name, T &t, const char* units = nullptr) {
+  return hrp<T>(name, t, units);
 }
 
-#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_val<T> make_hrp(const char *name, T &&t, const char* units = nullptr) {
+  return hrp_val<T>(name, t, units);
+}
+
+template <class T>
+inline hrp_enum<T> make_hrp_enum(const char *name, T &t, const std::vector<std::string>& labels, const char* units = nullptr) {
+  return hrp_enum<T>(name, t, labels, units);
+}
+
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_enum_val<T> make_hrp_enum(const char *name, T &&t, const std::vector<std::string>& labels, const char* units = nullptr) {
+  return hrp_enum_val<T>(name, t, labels, units);
+}
+
+template <class T>
+inline hrp<T> make_nvp(const char *name, T &t, const char* units) {
+  return hrp<T>(name, t, units);
+}
+
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_val<T> make_nvp(const char *name, T &&t, const char* units) {
+  return hrp_val<T>(name, t, units);
+}
+
+
 
 } // namespace serialization
 } // namespace boost
@@ -128,7 +289,41 @@ namespace uLib {
 
 #define _AR_OP(r, data, elem) data &BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
 
-#define NVP(data) BOOST_SERIALIZATION_NVP(data)
+// NAME VALUE PAIR //
+#define NVP_GET_MACRO(_1, _2, _3, NAME, ...) NAME
+#define NVP(...) NVP_GET_MACRO(__VA_ARGS__, NVP3, NVP2, NVP1)(__VA_ARGS__)
+
+#define NVP1(data) BOOST_SERIALIZATION_NVP(data)
+#define NVP2(name, data) boost::serialization::make_nvp(name, data)
+#define NVP3(name, data, units) boost::serialization::make_nvp(name, data, units)
+
+
+// HUMAN READABLE PROPERTY //
+#define HRP_GET_MACRO(_1, _2, _3, _4, _5, _6, NAME, ...) NAME
+#define HRP(...) HRP_GET_MACRO(__VA_ARGS__, HRP6, HRP5, HRP4, HRP3, HRP2, HRP1)(__VA_ARGS__)
+
+#define HRP1(data) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(data), data)
+#define HRP2(name, data) boost::serialization::make_hrp(name, data)
+#define HRP3(name, data, units) boost::serialization::make_hrp(name, data, units)
+#define HRP4(name, data, units, default) boost::serialization::make_hrp(name, data, units).set_default(default)
+#define HRP5(name, data, units, min, max) boost::serialization::make_hrp(name, data, units).range(min, max)
+#define HRP6(name, data, units, default, min, max) boost::serialization::make_hrp(name, data, units).set_default(default).range(min, max)
+
+#define HRPE(name, data, labels) boost::serialization::make_hrp_enum(name, data, labels)
+
+// LEFT FOR BACKWARD COMPATIBILITY
+#define HRPU(name, units) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name, units)
+
+
+
+
+
+namespace serialization {
+using boost::serialization::make_nvp;
+using boost::serialization::make_hrp;
+using boost::serialization::make_hrp_enum;
+} // serialization
+
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -156,7 +351,7 @@ namespace uLib {
 #define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
   _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
 #define AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
-#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
+#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_HR_(_name)
 #endif
 
 #define ULIB_SERIALIZE_ACCESS                                                  \
@@ -169,14 +364,14 @@ namespace uLib {
 #define ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass)                      \
   BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
 
-#define _SERIALIZE_IMPL_SEQ                                                                   \
-  (uLib::Archive::text_iarchive)(uLib::Archive::text_oarchive)(                               \
-      uLib::Archive::                                                                         \
-          hrt_iarchive)(uLib::Archive::                                                       \
-                            hrt_oarchive)(uLib::Archive::                                     \
-                                              xml_iarchive)(uLib::Archive::                   \
-                                                                xml_oarchive)(uLib::Archive:: \
-                                                                                  log_archive)
+#define _SERIALIZE_IMPL_SEQ  \
+  (uLib::Archive::text_iarchive) \
+  (uLib::Archive::text_oarchive) \
+  (uLib::Archive::hrt_iarchive)  \
+  (uLib::Archive::hrt_oarchive)  \
+  (uLib::Archive::xml_iarchive)  \
+  (uLib::Archive::xml_oarchive)  \
+  (uLib::Archive::log_archive)
 
 /** Solving virtual class check problem */
 #define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived)               \
@@ -247,6 +442,11 @@ namespace uLib {
   template <class ArchiveT>                                                    \
   void _Ob::save_override(ArchiveT &ar, const unsigned int version)
 
+
+
+
+
+  
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -351,7 +551,8 @@ namespace uLib {
   void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {        \
     /* PP  serialize */ BOOST_PP_SEQ_FOR_EACH(                                 \
         _UNAR_OP, ob, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));                   \
-  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }                                                          \
+  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>                     \
+  (uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }\
   template <class ArchiveT>                                                    \
   inline void load_construct_data(ArchiveT &ar, _Ob *ob,                       \
                                   const unsigned int file_version) {           \
@@ -374,10 +575,18 @@ namespace uLib {
                         _SERIALIZE_IMPL_SEQ)                                   \
   template <class ArchiveT>                                                    \
   void boost::serialization::access2<_Ob>::save_override(                      \
-      ArchiveT &ar, _Ob &ob, const unsigned int version)
+      ArchiveT &ar, _Ob &ob, const unsigned int version) 
 
+    
 #define _ULIB_DETAIL_UNINTRUSIVE_AR_(name)                                     \
   boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), ob.name)
+#define _ULIB_DETAIL_UNINTRUSIVE_HR_(name)                                     \
+  boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), ob.name)
+
+
+
+
+
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

src/Core/Signal.h

@@ -31,6 +31,8 @@
 #include <boost/signals2/signal.hpp>
 #include <boost/signals2/signal_type.hpp>
 #include <boost/signals2/slot.hpp>
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/shared_connection_block.hpp>
 
 #include "Function.h"
 #include <boost/bind/bind.hpp>
@@ -43,17 +45,31 @@ using namespace boost::placeholders;
 // Signals macro //
 
 #define default(vlaue)
-#define slots
+#ifndef Q_MOC_RUN
+#ifndef signals
 #define signals /*virtual void init_signals();*/ public
+#endif
+#ifndef slots
+#define slots
+#endif
+#ifndef emit
 #define emit
+#endif
+#endif
+#ifndef SLOT
 #define SLOT(a) BOOST_STRINGIZE(a)
+#endif
+#ifndef SIGNAL
 #define SIGNAL(a) BOOST_STRINGIZE(a)
+#endif
 
 #define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...)                                   \
   do {                                                                         \
-    BOOST_AUTO(sig, this->findOrAddSignal(&_name));                            \
-    if (sig)                                                                   \
-      sig->operator()(__VA_ARGS__);                                            \
+    if (!this->signalsBlocked()) {                                             \
+        BOOST_AUTO(sig, this->findOrAddSignal(&_name));                        \
+        if (sig)                                                               \
+          sig->operator()(__VA_ARGS__);                                        \
+    }                                                                          \
   } while (0)
 
 /**
@@ -78,6 +94,9 @@ namespace uLib {
 // TODO ...
 
 typedef boost::signals2::signal_base SignalBase;
+typedef boost::signals2::connection Connection;
+typedef boost::signals2::shared_connection_block ConnectionBlock;
+
 
 template <typename T> struct Signal {
   typedef boost::signals2::signal<T> type;
@@ -92,57 +111,57 @@ struct ConnectSignal {};
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 0> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(slof);
+    return reinterpret_cast<SigT *>(sigb)->connect(slof);
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 1> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
+    return reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 2> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
+    return reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 3> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(
+    return reinterpret_cast<SigT *>(sigb)->connect(
         boost::bind(slof, receiver, _1, _2));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 4> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(
+    return reinterpret_cast<SigT *>(sigb)->connect(
         boost::bind(slof, receiver, _1, _2, _3));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 5> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(
+    return reinterpret_cast<SigT *>(sigb)->connect(
         boost::bind(slof, receiver, _1, _2, _3, _4));
   }
 };
@@ -155,11 +174,11 @@ template <typename FuncT> SignalBase *NewSignal(FuncT f) {
 }
 
 template <typename SigSignature, typename FuncT>
-void ConnectSignal(SignalBase *sigb, FuncT slof,
+Connection ConnectSignal(SignalBase *sigb, FuncT slof,
                    typename FunctionPointer<FuncT>::Object *receiver) {
-  detail::ConnectSignal<FuncT, SigSignature,
-                        FunctionPointer<FuncT>::arity>::connect(sigb, slof,
-                                                                receiver);
+  return detail::ConnectSignal<FuncT, SigSignature,
+                         FunctionPointer<FuncT>::arity>::connect(sigb, slof,
+                                                                 receiver);
 }
 
 } // namespace uLib

src/Core/Threads.cpp

@@ -0,0 +1,202 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#include "Threads.h"
+#include <chrono>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#ifdef __linux__
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+namespace uLib {
+
+Thread::Thread() : m_Running(false) {}
+
+Thread::~Thread() {
+  if (m_Thread.joinable()) {
+    m_Thread.detach();
+  }
+}
+
+void Thread::Start() {
+  Mutex::ScopedLock lock(m_ThreadMutex);
+  if (m_Running) return;
+  
+  m_Running = true;
+  m_Thread = std::thread(&Thread::ThreadEntryPoint, this);
+}
+
+void Thread::Join() {
+  if (m_Thread.joinable()) {
+    m_Thread.join();
+  }
+}
+
+void Thread::Detach() {
+  if (m_Thread.joinable()) {
+    m_Thread.detach();
+  }
+}
+
+bool Thread::IsJoinable() const {
+  return m_Thread.joinable();
+}
+
+bool Thread::IsRunning() const {
+  return m_Running;
+}
+
+void Thread::Run() {
+  // Override in subclasses
+}
+
+void Thread::ThreadEntryPoint() {
+  this->Run();
+  m_Running = false;
+}
+
+void Thread::Sleep(int milliseconds) {
+  std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+}
+
+void Thread::Yield() {
+  std::this_thread::yield();
+}
+
+void Thread::SetAffinity(int cpu) {
+#ifdef __linux__
+  if (m_Thread.joinable()) {
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(cpu, &cpuset);
+    pthread_setaffinity_np(m_Thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+  }
+#endif
+}
+
+void Thread::SetAffinity(const std::vector<int>& cpus) {
+#ifdef __linux__
+  if (m_Thread.joinable()) {
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    for (int cpu : cpus) {
+        CPU_SET(cpu, &cpuset);
+    }
+    pthread_setaffinity_np(m_Thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+  }
+#endif
+}
+
+void Thread::SetNumThreads(int n) {
+#ifdef _OPENMP
+  omp_set_num_threads(n);
+#endif
+}
+
+int Thread::GetNumThreads() {
+#ifdef _OPENMP
+  return omp_get_max_threads();
+#else
+  return 1;
+#endif
+}
+
+int Thread::GetThreadNum() {
+#ifdef _OPENMP
+  return omp_get_thread_num();
+#else
+  return 0;
+#endif
+}
+
+// Team Implementation //
+
+Team::Team(int num_threads) : m_Size(num_threads), m_UseOpenMP(false) {
+#ifdef _OPENMP
+  m_UseOpenMP = true;
+  if (m_Size > 0) omp_set_num_threads(m_Size);
+  else m_Size = omp_get_max_threads();
+#else
+  if (m_Size <= 0) m_Size = 1;
+#endif
+}
+
+Team::~Team() {
+  Wait();
+}
+
+void Team::Run(Task* task) {
+  if (!task) return;
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp task
+    task->Execute();
+    return;
+  }
+#endif
+  // Fallback to synchronous execution if no OpenMP
+  task->Execute();
+}
+
+void Team::Wait() {
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp taskwait
+  }
+#endif
+}
+
+void Team::SetSize(int n) {
+  m_Size = n;
+#ifdef _OPENMP
+  if (m_UseOpenMP) omp_set_num_threads(m_Size);
+#endif
+}
+
+void Team::SetAffinity(const std::vector<int>& cpus) {
+  if (cpus.empty()) return;
+#ifdef __linux__
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp parallel
+    {
+      int tid = omp_get_thread_num();
+      int cpu = cpus[tid % cpus.size()];
+      cpu_set_t cpuset;
+      CPU_ZERO(&cpuset);
+      CPU_SET(cpu, &cpuset);
+      pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+    }
+  }
+#endif
+#endif
+}
+
+} // namespace uLib

src/Core/Threads.h

@@ -0,0 +1,147 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CORE_THREADS_H
+#define U_CORE_THREADS_H
+
+#include <thread>
+#include <functional>
+#include <atomic>
+#include <vector>
+#include <deque>
+#include "Core/Monitor.h"
+#include "Core/Object.h"
+
+namespace uLib {
+
+/**
+ * @brief Thread class wraps std::thread and provides a common interface.
+ */
+class Thread : public Object {
+public:
+  Thread();
+  virtual ~Thread();
+
+  /** @brief Starts the thread by calling Run(). */
+  void Start();
+
+  /** @brief Joins the thread. */
+  void Join();
+
+  /** @brief Detaches the thread. */
+  void Detach();
+
+  /** @brief Returns true if the thread is currently joinable. */
+  bool IsJoinable() const;
+  
+  /** @brief Returns true if the thread is currently running. */
+  bool IsRunning() const;
+
+  /** @brief The entry point for the thread. Override this in subclasses. */
+  virtual void Run();
+
+  /** @brief Static helper to sleep the current thread. */
+  static void Sleep(int milliseconds);
+
+  /** @brief Static helper to yield the current thread. */
+  static void Yield();
+
+  /** @brief Returns the native handle of the thread. */
+  std::thread::native_handle_type GetNativeHandle() { return m_Thread.native_handle(); }
+
+  /** @brief Sets CPU affinity for the thread. (Linux only) */
+  void SetAffinity(int cpu);
+  
+  /** @brief Sets CPU affinity for the thread using a list of CPUs. (Linux only) */
+  void SetAffinity(const std::vector<int>& cpus);
+
+  // OpenMP Support //
+  
+  /** @brief Sets the number of threads for OpenMP parallel regions. */
+  static void SetNumThreads(int n);
+  
+  /** @brief Returns the number of threads for OpenMP parallel regions. */
+  static int GetNumThreads();
+
+  /** @brief Returns the ID of the current thread in an OpenMP parallel region. */
+  static int GetThreadNum();
+
+protected:
+  // Internal thread entry point
+  void ThreadEntryPoint();
+
+  std::thread m_Thread;
+  std::atomic<bool> m_Running;
+  mutable Mutex m_ThreadMutex;
+};
+
+/**
+ * @brief Task class wraps a function call to be executed by a Team.
+ */
+class Task : public Object {
+public:
+  Task(std::function<void()> func) : m_Func(func) {}
+  virtual ~Task() = default;
+
+  /** @brief Executes the task. */
+  virtual void Execute() { if (m_Func) m_Func(); }
+
+protected:
+  std::function<void()> m_Func;
+};
+
+/**
+ * @brief Team class manages a group of threads and can execute Tasks.
+ * This is designed to be compatible with OpenMP tasks and teams.
+ */
+class Team : public Object {
+public:
+  Team(int num_threads = -1);
+  virtual ~Team();
+
+  /** @brief Runs a task within the team. Uses OpenMP task if available. */
+  void Run(Task* task);
+
+  /** @brief Waits for all tasks in the team to finish. */
+  void Wait();
+
+  /** @brief Sets the number of threads for this team. */
+  void SetSize(int n);
+
+  /** @brief Returns the number of threads in the team. */
+  int GetSize() const { return m_Size; }
+
+  /** @brief Sets CPU affinity for all threads in the team. */
+  void SetAffinity(const std::vector<int>& cpus);
+
+protected:
+  int m_Size;
+  bool m_UseOpenMP;
+  std::vector<Thread*> m_Threads;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_THREADS_H

src/Core/Types.h

@@ -139,6 +139,7 @@ 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/AffinityTest.cpp

@@ -0,0 +1,65 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <vector>
+#include <cassert>
+
+#ifdef __linux__
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+using namespace uLib;
+
+void TestThreadAffinity() {
+    std::cout << "Testing Thread Affinity..." << std::endl;
+#ifdef __linux__
+    Thread t;
+    t.Start();
+    t.SetAffinity(0); // Bind to CPU 0
+    
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
+    assert(CPU_ISSET(0, &cpuset));
+    
+    t.Join();
+    std::cout << "  Passed (Thread bound to CPU 0)." << std::endl;
+#else
+    std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
+#endif
+}
+
+void TestTeamAffinity() {
+    std::cout << "Testing Team Affinity..." << std::endl;
+#ifdef __linux__
+#ifdef _OPENMP
+    Team team(2);
+    std::vector<int> cpus = {0, 1};
+    team.SetAffinity(cpus);
+    
+    // We check affinity inside a parallel region
+    #pragma omp parallel
+    {
+        cpu_set_t cpuset;
+        CPU_ZERO(&cpuset);
+        pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+        int tid = Thread::GetThreadNum();
+        int expected_cpu = cpus[tid % cpus.size()];
+        assert(CPU_ISSET(expected_cpu, &cpuset));
+    }
+    std::cout << "  Passed (Team threads bound correctly)." << std::endl;
+#endif
+#else
+    std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
+#endif
+}
+
+// Helper to get native handle if needed (oops, I forgot to add it to Thread class)
+// I'll add GetNativeHandle() to Thread class in Threads.h
+
+int main() {
+    TestThreadAffinity();
+    TestTeamAffinity();
+    std::cout << "All Affinity tests finished!" << std::endl;
+    return 0;
+}

src/Core/testing/CMakeLists.txt

@@ -21,6 +21,15 @@ set( TESTS
         OptionsTest
         PingPongTest
         VectorMetaAllocatorTest
+        PropertyTypesTest
+        HRPTest
+        PropertyGroupingTest
+        MutexTest
+        ThreadsTest
+        OpenMPTest
+        TeamTest
+        AffinityTest
+        ReadOnlyPropertyTest
 )
 
 set(LIBRARIES
@@ -29,6 +38,7 @@ set(LIBRARIES
        Boost::serialization
        Boost::program_options
        ${ROOT_LIBRARIES}
+       OpenMP::OpenMP_CXX
 )
 uLib_add_tests(Core)
 

src/Core/testing/HRPTest.cpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <sstream>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
+#include "Core/Archives.h"
+
+using namespace uLib;
+
+struct SimpleObject {
+    int value;
+    std::string name;
+ 
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(value);
+        ar & HRP(name);
+    }
+};
+ 
+struct DynamicObject : public Object {
+    float width;
+    int height;
+ 
+    DynamicObject() : width(10.0f), height(20) {
+        // Automatic registration of properties based on serialize/HRP
+        ULIB_ACTIVATE_PROPERTIES(*this);
+    }
+ 
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(width);
+        ar & HRP(height);
+    }
+};
+
+int main() {
+    SimpleObject obj;
+    obj.value = 42;
+    obj.name = "TestObject";
+
+    std::cout << "Testing HRP Serialization to Log..." << std::endl;
+    std::stringstream ss;
+    {
+        uLib::Archive::log_archive ar(ss);
+        ar << boost::serialization::make_nvp("Object", obj);
+    }
+    std::cout << ss.str() << std::endl;
+
+    std::cout << "Testing HRP Serialization to HRT..." << std::endl;
+    ss.str("");
+    {
+        uLib::Archive::hrt_oarchive ar(ss);
+        ar << obj;
+    }
+    std::cout << ss.str() << std::endl;
+ 
+    std::cout << "Testing HRP Serialization to XML..." << std::endl;
+    ss.str("");
+    {
+        uLib::Archive::xml_oarchive ar(ss);
+        ar << boost::serialization::make_nvp("Object", obj);
+    }
+    std::cout << ss.str() << std::endl;
+ 
+    std::cout << "Testing Dynamic Property Creation via ULIB_ACTIVATE_PROPERTIES macro..." << std::endl;
+    DynamicObject dynObj;
+    // (properties were already created in DynamicObject constructor via macro)
+    
+    std::cout << "Registered Properties in dynObj:" << std::endl;
+    const auto& props = dynObj.GetProperties();
+    for (auto* p : props) {
+        std::cout << "  - [" << p->GetTypeName() << "] " << p->GetName() << " = " << p->GetValueAsString() << std::endl;
+    }
+    
+    if (props.size() == 2) {
+        std::cout << "Dynamic Property Creation SUCCESS!" << std::endl;
+    } else {
+        std::cout << "Dynamic Property Creation FAILED (Expected 2, got " << props.size() << ")" << std::endl;
+    }
+ 
+    return 0;
+}

src/Core/testing/MutexTest.cpp

@@ -0,0 +1,109 @@
+#include "Core/Monitor.h"
+#include <iostream>
+#include <chrono>
+#include <thread>
+#include <vector>
+#include <cassert>
+
+using namespace uLib;
+
+void TestBasicLock() {
+    std::cout << "Testing basic Mutex Lock/Unlock..." << std::endl;
+    Mutex m;
+    m.Lock();
+    m.Unlock();
+    assert(m.TryLock());
+    m.Unlock();
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestScopedLock() {
+    std::cout << "Testing Mutex::ScopedLock..." << std::endl;
+    Mutex m;
+    {
+        Mutex::ScopedLock lock(m);
+        assert(!m.TryLock());
+    }
+    assert(m.TryLock());
+    m.Unlock();
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestTimedLock() {
+    std::cout << "Testing Mutex TryLockFor..." << std::endl;
+    Mutex m;
+    m.Lock();
+    auto start = std::chrono::steady_clock::now();
+    bool locked = m.TryLockFor(100);
+    auto end = std::chrono::steady_clock::now();
+    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+    
+    assert(!locked);
+    assert(diff >= 100);
+    m.Unlock();
+    std::cout << "  Passed (waited " << diff << "ms)." << std::endl;
+}
+
+void TestMacros() {
+    std::cout << "Testing ULIB_STATIC_LOCK and ULIB_MUTEX_LOCK macros..." << std::endl;
+    
+    int counter = 0;
+    auto task = [&]() {
+        for(int i=0; i<500; ++i) {
+            ULIB_STATIC_LOCK(-1) {
+                counter++;
+            }
+        }
+    };
+    
+    std::vector<std::thread> threads;
+    for(int i=0; i<4; ++i) threads.emplace_back(task);
+    for(auto& t : threads) t.join();
+    
+    assert(counter == 2000);
+    
+    Mutex m;
+    int counter2 = 0;
+    ULIB_MUTEX_LOCK(m, -1) {
+        counter2++;
+    }
+    assert(counter2 == 1);
+    
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestMonitor() {
+    std::cout << "Testing Monitor pattern..." << std::endl;
+    struct Resource {
+        int value = 0;
+        void increment() { value++; }
+    };
+    
+    Monitor<Resource> monitor(new Resource());
+    
+    auto task = [&]() {
+        for(int i=0; i<1000; ++i) {
+            monitor.Access([](Resource& r) {
+                r.increment();
+            });
+        }
+    };
+    
+    std::vector<std::thread> threads;
+    for(int i=0; i<5; ++i) threads.emplace_back(task);
+    for(auto& t : threads) t.join();
+    
+    int final_value = monitor.Access([](Resource& r) { return r.value; });
+    assert(final_value == 5000);
+    std::cout << "  Passed (final value: " << final_value << ")." << std::endl;
+}
+
+int main() {
+    TestBasicLock();
+    TestScopedLock();
+    TestTimedLock();
+    TestMacros();
+    TestMonitor();
+    std::cout << "All Mutex and Monitor tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/OpenMPTest.cpp

@@ -0,0 +1,47 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <cassert>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+using namespace uLib;
+
+class OpenMPThread : public Thread {
+public:
+    void Run() override {
+#ifdef _OPENMP
+        Thread::SetNumThreads(2);
+        int max = Thread::GetNumThreads();
+        std::cout << "  OpenMP max threads in uLib::Thread: " << max << std::endl;
+        
+        int shared_counter = 0;
+        #pragma omp parallel reduction(+:shared_counter)
+        {
+            shared_counter += 1;
+        }
+        std::cout << "  Parallel region executed with " << shared_counter << " threads." << std::endl;
+        assert(shared_counter <= max);
+#else
+        std::cout << "  OpenMP not available, skipping parallel check." << std::endl;
+        assert(Thread::GetNumThreads() == 1);
+#endif
+    }
+};
+
+int main() {
+    std::cout << "Testing OpenMP compatibility..." << std::endl;
+#ifdef _OPENMP
+    std::cout << "  OpenMP is AVAILABLE." << std::endl;
+#else
+    std::cout << "  OpenMP is NOT available." << std::endl;
+#endif
+
+    OpenMPThread t;
+    t.Start();
+    t.Join();
+
+    std::cout << "OpenMP compatibility test finished!" << std::endl;
+    return 0;
+}

src/Core/testing/PropertiesTest.cpp

@@ -23,74 +23,138 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 #include <iostream>
-
-#include <boost/signals2/signal.hpp>
-
+#include <fstream>
+#include <string>
 
 #include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Archives.h"
+#include "Core/Serializable.h"
 #include "testing-prototype.h"
 
-#define emit
-
-
-
-
-template <typename T, bool copyable = true>
-class property
-{
-    typedef boost::signals2::signal<void(const property<T>& )> signal_t;
+using namespace uLib;
 
+/**
+ * @brief A test class to demonstrate property registration via SERIALIZE_OBJECT.
+ */
+class TestObject : public Object {
 public:
-    property() : m_changed(new signal_t) {}
-    property(const T in) : value(in) , m_changed(new signal_t) {}
+    uLibTypeMacro(TestObject, Object)
 
-    inline operator T const & () const { return value; }
-    inline operator T & () { return value; }
-    inline T & operator = (const T &i) { value = i; return value; }
-    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }    // Assign exact identical types only.
-    inline signal_t & valueChanged() { return *m_changed; }
+    TestObject() : m_Value(10.5f), m_Status("Initialized"), m_Counter(0) {}
+
+    float m_Value;
+    std::string m_Status;
+    int m_Counter;
+
+    // Static properties (registered in constructor/initializer)
+    ULIB_PROPERTY(int, StaticProp, 42)
+
+    ULIB_SERIALIZE_ACCESS
+
+    template <typename Ar>
+    void serialize(Ar& ar, unsigned int version) {
+        ar & HRP("value", m_Value, "mm").range(0, 100).set_default(1.);
+        ar & HRP("status", m_Status);
+        ar & HRP("counter", m_Counter);
+    }
 
-private:
-    T value;
-    boost::shared_ptr<signal_t> m_changed;
 };
 
 
-//template <typename T>
-//class property <T,false> {
-//    typedef boost::signals2::signal<void( T )> signal_t;
+class TestObject2 : public TestObject {
+public:
+    uLibTypeMacro(TestObject2, TestObject)
 
-//public:
-//    property() : m_changed() {}
-//    property(const T in) : value(in) , m_changed() {}
+    TestObject2() : TestObject(), m_Value2(20.5f) {}
 
-//    inline operator T const & () const { return value; }
-//    inline operator T & () { valueChanged()(value); return value; }
-//    inline T & operator = (const T &i) { value = i; valueChanged()(value); return value; }
-//    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }     // Assign exact identical types only.
-//    inline signal_t &valueChanged() { return m_changed; }
-
-//private:
-//    property(const property<T> &);
-//    property<T> &operator = (const property<T>&);
-
-//    T value;
-//    signal_t m_changed;
-//};
-
-// test generic void function slot //
-void PrintSlot(const property<int> &i) { std::cout << "slot called, new value = " << i << "!\n"; }
-
-
-
-
-
-int main()
-{    
+    float m_Value2;
 
+    ULIB_SERIALIZE_ACCESS
+};
 
+ULIB_SERIALIZABLE_OBJECT(TestObject2)
+ULIB_SERIALIZE_OBJECT(TestObject2, TestObject) { 
+    std::cout << "Serializing TestObject2" << std::endl;
+    // ar & boost::serialization::make_hrp("value2", ob.m_Value2, "mm").set_default(1.);
+    ar & HRP("value2", ob.m_Value2, "mm").set_default(1.);
+}
+
+
+int main() {
+    BEGIN_TESTING(Properties Serialization)
+
+    TestObject obj;
+    
+    // 1. Initial state: check static property
+    ASSERT_EQUAL(obj.StaticProp, 42);
+    
+    // 2. Activate dynamic properties via the property_register_archive
+    // This calls the serialize method with a special archive that populates m_DynamicProperties
+    ULIB_ACTIVATE_PROPERTIES(obj);
+    
+    const auto& props = obj.GetProperties();
+    // This is problematic because GetProperties currently returns d->m_Properties (only static) 
+    
+    // For now, let's just assert on the dynamic property presence if possible
+    PropertyBase* pVal = obj.GetProperty("value");
+    ASSERT_NOT_NULL(pVal);
+    ASSERT_EQUAL(pVal->GetValueAsString(), "10.5");
+    ASSERT_EQUAL(pVal->GetUnits(), "mm");
+
+    // Check other dynamic properties
+    ASSERT_NOT_NULL(obj.GetProperty("status"));
+    ASSERT_NOT_NULL(obj.GetProperty("counter"));
+
+    // 4. Serialization round-trip (XML)
+    {
+        std::ofstream ofs("test_props.xml");
+        Archive::xml_oarchive(ofs) << NVP("test_obj", obj);
+    }
+
+    TestObject obj2;
+    obj2.m_Value = 0;
+    obj2.m_Status = "";
+    {
+        std::ifstream ifs("test_props.xml");
+        Archive::xml_iarchive(ifs) >> NVP("test_obj", obj2);
+    }
+
+    ASSERT_EQUAL(obj2.m_Value, 10.5f);
+    ASSERT_EQUAL(obj2.m_Status, "Initialized");
+
+    TestObject2 obj3;
+    obj3.m_Value = 12.5;
+    obj3.m_Status = "Initialized";
+    obj3.m_Value2 = 22.5;
+
+    ULIB_ACTIVATE_PROPERTIES(obj3);
+
+    PropertyBase* pVal3 = obj3.GetProperty("value2");
+    ASSERT_NOT_NULL(pVal3);
+    ASSERT_EQUAL(pVal3->GetValueAsString(), "22.5");
+    ASSERT_EQUAL(pVal3->GetUnits(), "mm");
+
+    // 5. Serialization round-trip (XML)
+    {   
+        std::ofstream ofs("test_props2.xml");
+        Archive::xml_oarchive(ofs) << NVP("test_obj2", obj3);
+    }
+
+    TestObject2 obj4;
+    obj4.m_Value = 0;
+    obj4.m_Status = "";
+    obj4.m_Value2 = 0;
+    ULIB_ACTIVATE_PROPERTIES(obj4);
+    {   
+        std::ifstream ifs("test_props2.xml");
+        Archive::xml_iarchive(ifs) >> NVP("test_obj2", obj4);
+    }
+    ASSERT_EQUAL(obj4.m_Value, 12.5f);
+    ASSERT_EQUAL(obj4.m_Status, "Initialized");
+    ASSERT_EQUAL(obj4.m_Value2, 22.5f);
+
+
+    END_TESTING
 }

src/Core/testing/PropertyGroupingTest.cpp

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+
+using namespace uLib;
+
+struct Nested {
+    float x = 1.0f;
+    float y = 2.0f;
+
+    ULIB_SERIALIZE_ACCESS
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(x);
+        ar & HRP(y);
+    }
+};
+
+class GroupObject : public Object {
+    uLibTypeMacro(GroupObject, Object)
+public:
+    Nested position;
+    Nested orientation;
+    float weight = 50.0f;
+
+    ULIB_SERIALIZE_ACCESS
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & boost::serialization::make_nvp("Position", position);
+        ar & boost::serialization::make_nvp("Orientation", orientation);
+        ar & HRP(weight);
+    }
+};
+
+int main() {
+    std::cout << "Testing Property Grouping..." << std::endl;
+
+    GroupObject obj;
+    ULIB_ACTIVATE_PROPERTIES(obj);
+
+    auto props = obj.GetProperties();
+    std::cout << "Registered " << props.size() << " properties." << std::endl;
+
+    for (auto* p : props) {
+        std::cout << "Prop: " << p->GetName() 
+                  << " Group: " << p->GetGroup() 
+                  << " Qualified: " << p->GetQualifiedName() << std::endl;
+    }
+
+    // Check if nested properties are registered
+    PropertyBase* p1 = obj.GetProperty("Position.x");
+    PropertyBase* p2 = obj.GetProperty("Position.y");
+    PropertyBase* p3 = obj.GetProperty("Orientation.x");
+    PropertyBase* p4 = obj.GetProperty("Orientation.y");
+    PropertyBase* p5 = obj.GetProperty("weight");
+
+    assert(p1 != nullptr && "Position.x not found");
+    assert(p2 != nullptr && "Position.y not found");
+    assert(p3 != nullptr && "Orientation.x not found");
+    assert(p4 != nullptr && "Orientation.y not found");
+    assert(p5 != nullptr && "weight not found");
+
+    assert(p1->GetGroup() == "Position");
+    assert(p2->GetGroup() == "Position");
+    assert(p3->GetGroup() == "Orientation");
+    assert(p4->GetGroup() == "Orientation");
+    assert(p5->GetGroup() == "");
+
+    assert(p1->GetQualifiedName() == "Position.x");
+    assert(p5->GetQualifiedName() == "weight");
+
+    std::cout << "Property Grouping Tests PASSED!" << std::endl;
+
+    return 0;
+}

src/Core/testing/PropertySystemTest.cpp

@@ -0,0 +1,63 @@
+#include <iostream>
+#include <sstream>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include <cassert>
+
+using namespace uLib;
+
+class TestObject : public Object {
+public:
+  uLibTypeMacro(TestObject, Object)
+  TestObject() : Object(), 
+    IntProp(this, "IntProp", 10),
+    StringProp(this, "StringProp", "Initial") 
+  {}
+
+  Property<int> IntProp;
+  Property<std::string> StringProp;
+};
+
+int main() {
+  TestObject obj;
+  
+  std::cout << "Testing Properties..." << std::endl;
+  
+  // 1. Check registration
+  const auto& props = obj.GetProperties();
+  assert(props.size() == 2);
+  assert(props[0]->GetName() == "IntProp");
+  assert(props[1]->GetName() == "StringProp");
+  
+  // 2. Check value access and signals
+  bool signalCalled = false;
+  uLib::Object::connect(&obj.IntProp, &Property<int>::PropertyChanged, [&signalCalled]() {
+      signalCalled = true;
+  });
+  
+  assert(obj.IntProp.Get() == 10);
+  obj.IntProp = 20;
+  assert(obj.IntProp.Get() == 20);
+  assert(signalCalled == true);
+  
+  // 3. Check serialization
+  std::stringstream ss;
+  Object::SaveXml(ss, obj);
+  std::string xml = ss.str();
+  std::cout << "Serialized XML: \n" << xml << std::endl;
+  
+  assert(xml.find("<IntProp>20</IntProp>") != std::string::npos);
+  assert(xml.find("<StringProp>Initial</StringProp>") != std::string::npos);
+  
+  // 4. Check deserialization
+  TestObject obj2;
+  std::stringstream ss2(xml);
+  Object::LoadXml(ss2, obj2);
+  
+  assert(obj2.IntProp.Get() == 20);
+  assert(obj2.StringProp.Get() == "Initial");
+  
+  std::cout << "All Property Tests PASSED!" << std::endl;
+  
+  return 0;
+}

src/Core/testing/PropertyTypesTest.cpp

@@ -0,0 +1,67 @@
+#include <iostream>
+#include <sstream>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Math/Dense.h"
+
+using namespace uLib;
+
+class TestObject : public Object {
+public:
+  uLibTypeMacro(TestObject, Object)
+  TestObject() : Object() {}
+
+  // Use new typedefs
+  StringProperty  StringProp = StringProperty(this, "StringProp", "Initial");
+  IntProperty     IntProp    = IntProperty(this, "IntProp", 42);
+  FloatProperty   FloatProp  = FloatProperty(this, "FloatProp", 3.14f);
+  BoolProperty    BoolProp   = BoolProperty(this, "BoolProp", true);
+
+  // Use new macro
+  ULIB_PROPERTY(Matrix3f, MatrixProp, Matrix3f::Identity())
+
+  // Use new Dense typedefs
+  Vector3fProperty Vector3fProp = Vector3fProperty(this, "Vector3fProp", Vector3f(1.1f, 2.2f, 3.3f));
+  Matrix4fProperty Matrix4fProp = Matrix4fProperty(this, "Matrix4fProp", Matrix4f::Identity());
+};
+
+int main() {
+  TestObject obj;
+  
+  std::cout << "Testing Property Types..." << std::endl;
+  
+  // 1. Verify string representation
+  std::cout << "StringProp: " << obj.StringProp.GetValueAsString() << std::endl;
+  assert(obj.StringProp.GetValueAsString() == "Initial");
+
+  std::cout << "IntProp: " << obj.IntProp.GetValueAsString() << std::endl;
+  assert(obj.IntProp.GetValueAsString() == "42");
+
+  std::cout << "FloatProp: " << obj.FloatProp.GetValueAsString() << std::endl;
+  // boost::lexical_cast might have different precision, but for 3.14 it should be okay or we check find
+  assert(obj.FloatProp.GetValueAsString().find("3.14") != std::string::npos);
+
+  std::cout << "BoolProp: " << obj.BoolProp.GetValueAsString() << std::endl;
+  // Bool might be "1" or "true" depending on lexical_cast/stringstream
+  assert(obj.BoolProp.GetValueAsString() == "1" || obj.BoolProp.GetValueAsString() == "true");
+
+  // 2. Verify Matrix/Vector string representation (uses operator<<)
+  std::cout << "MatrixProp: \n" << obj.MatrixProp.GetValueAsString() << std::endl;
+  assert(obj.MatrixProp.GetValueAsString().find("1 0 0") != std::string::npos);
+
+  std::cout << "Vector3fProp: " << obj.Vector3fProp.GetValueAsString() << std::endl;
+  assert(obj.Vector3fProp.GetValueAsString().find("1.1 2.2 3.3") != std::string::npos);
+
+  std::cout << "Matrix4fProp: \n" << obj.Matrix4fProp.GetValueAsString() << std::endl;
+  assert(obj.Matrix4fProp.GetValueAsString().find("1 0 0 0") != std::string::npos);
+
+  // 3. Verify updates and signals
+  obj.IntProp = 100;
+  assert(obj.IntProp.Get() == 100);
+  assert(obj.IntProp.GetValueAsString() == "100");
+
+  std::cout << "All Property Type Tests PASSED!" << std::endl;
+  
+  return 0;
+}

src/Core/testing/ReadOnlyPropertyTest.cpp

@@ -0,0 +1,82 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
+
+#include "Core/Serializable.h"
+
+using namespace uLib;
+
+class ReadOnlyTestObject : public Object {
+public:
+    int m_value;
+    int getValue() const { return m_value; }
+    
+    enum State { State1, State2 };
+    State m_state;
+    State getState() const { return m_state; }
+
+    ReadOnlyTestObject() : m_value(10), m_state(State1) {
+        ULIB_ACTIVATE_PROPERTIES(*this);
+    }
+
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        // Lvalue reference - should be NOT read-only
+        ar & HRP("lvalue_prop", m_value);
+        
+        // Rvalue from getter - should be read-only
+        ar & HRP("rvalue_prop", getValue());
+        
+        // Enum lvalue - should be NOT read-only
+        ar & boost::serialization::make_hrp_enum("lvalue_enum", (int&)m_state, {"State1", "State2"});
+        
+        // Enum rvalue - should be read-only
+        ar & boost::serialization::make_hrp_enum("rvalue_enum", (int)getState(), {"State1", "State2"});
+    }
+};
+
+int main() {
+    std::cout << "Testing Read-Only Property Feature..." << std::endl;
+    
+    ReadOnlyTestObject obj;
+    const auto& props = obj.GetProperties();
+    
+    std::cout << "Registered Properties in ReadOnlyTestObject:" << std::endl;
+    bool found_lvalue = false;
+    bool found_rvalue = false;
+    bool found_lvalue_enum = false;
+    bool found_rvalue_enum = false;
+
+    for (auto* p : props) {
+        bool ro = p->IsReadOnly();
+        std::cout << "  - Name: " << p->GetName() 
+                  << " | Type: " << p->GetTypeName() 
+                  << " | ReadOnly: " << (ro ? "YES" : "NO") << std::endl;
+        
+        if (p->GetName() == "lvalue_prop") {
+            if (ro) { std::cerr << "FAIL: lvalue_prop should NOT be read-only" << std::endl; return 1; }
+            found_lvalue = true;
+        } else if (p->GetName() == "rvalue_prop") {
+            if (!ro) { std::cerr << "FAIL: rvalue_prop SHOULD be read-only" << std::endl; return 1; }
+            found_rvalue = true;
+        } else if (p->GetName() == "lvalue_enum") {
+            if (ro) { std::cerr << "FAIL: lvalue_enum should NOT be read-only" << std::endl; return 1; }
+            found_lvalue_enum = true;
+        } else if (p->GetName() == "rvalue_enum") {
+            if (!ro) { std::cerr << "FAIL: rvalue_enum SHOULD be read-only" << std::endl; return 1; }
+            found_rvalue_enum = true;
+        }
+    }
+    
+    if (found_lvalue && found_rvalue && found_lvalue_enum && found_rvalue_enum) {
+        std::cout << "TEST PASSED SUCCESSFULLY!" << std::endl;
+        return 0;
+    } else {
+        std::cerr << "TEST FAILED: Some properties were not found!" << std::endl;
+        return 1;
+    }
+}

src/Core/testing/SerializeDreadDiamondTest.cpp

@@ -40,7 +40,7 @@ struct A : Object {
 };
 
 ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A, Object) { ar &AR(numa); }
+ULIB_SERIALIZE_OBJECT(A, Object) { ar & AR(numa); }
 
 struct B : virtual Object {
   uLibTypeMacro(B, Object) B() : numb(5552369) {}
@@ -48,7 +48,7 @@ struct B : virtual Object {
 };
 
 ULIB_SERIALIZABLE_OBJECT(B)
-ULIB_SERIALIZE_OBJECT(B, Object) { ar &AR(numb); }
+ULIB_SERIALIZE_OBJECT(B, Object) { ar & AR(numb); }
 
 struct C : B {
   uLibTypeMacro(C, B) C() : numc(5552370) {}
@@ -56,7 +56,7 @@ struct C : B {
 };
 
 ULIB_SERIALIZABLE_OBJECT(C)
-ULIB_SERIALIZE_OBJECT(C, B) { ar &AR(numc); }
+ULIB_SERIALIZE_OBJECT(C, B) { ar & AR(numc); }
 
 struct D : A, B {
   uLibTypeMacro(D, A, B)
@@ -67,10 +67,33 @@ struct D : A, B {
 };
 
 ULIB_SERIALIZABLE_OBJECT(D)
-ULIB_SERIALIZE_OBJECT(D, A, B) { ar &AR(numd); }
+ULIB_SERIALIZE_OBJECT(D, A, B) { ar & AR(numd); }
 
 int main() {
-  A o;
-
-  Archive::xml_oarchive(std::cout) << NVP(o);
+  BEGIN_TESTING(DreadDiamond Serialization)
+  
+  D o;
+  C c;
+  c.numb = 123;
+  {
+    std::ofstream file("test.xml");
+    Archive::xml_oarchive(file) << NVP("dd_test", o) << NVP("c", c);
+  }
+  {
+    D o2;
+    C c2;
+    std::ifstream file("test.xml");
+    Archive::xml_iarchive(file) >> NVP("dd_test", o2) >> NVP("c", c2);
+    
+    // D //
+    ASSERT_EQUAL(o.numa, o2.numa);
+    ASSERT_EQUAL(o.numb, o2.numb);
+    ASSERT_EQUAL(o.numd, o2.numd);
+    
+    // C //
+    ASSERT_EQUAL(c.numb, c2.numb);
+    ASSERT_EQUAL(c.numc, c2.numc);
+  }
+  
+  END_TESTING
 }

src/Core/testing/SerializeTest.cpp

@@ -143,22 +143,19 @@ int testing_hrt_class() {
   }
   a.a() = 0;
   a.p_a = "zero string";
-  {
-    // ERRORE FIX !
-    //        std::ifstream file("test.xml");
-    //        Archive::hrt_iarchive(file) >> NVP(a);
-  }
 
   Archive::hrt_oarchive(std::cout) << NVP(a);
   return (a.a() == 5552368 && a.p_a == "A property string");
 }
 
+
+
 int main() {
   BEGIN_TESTING(Serialize Test);
 
   TEST1(test_V3f());
   TEST1(testing_xml_class());
-  //    testing_hrt_class(); ///// << ERRORE in HRT with properties
+  // TEST1(testing_hrt_class());
 
   END_TESTING;
 }

src/Core/testing/TeamTest.cpp

@@ -0,0 +1,40 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <atomic>
+#include <cassert>
+#include <vector>
+
+using namespace uLib;
+
+void TestTaskTeam() {
+    std::cout << "Testing Task and Team..." << std::endl;
+    
+    std::atomic<int> counter(0);
+    auto task_func = [&]() {
+        counter++;
+        Thread::Sleep(10);
+    };
+    
+    Team team(4);
+    std::cout << "  Team size: " << team.GetSize() << std::endl;
+
+#ifdef _OPENMP
+    #pragma omp parallel
+    #pragma omp single
+#endif
+    {
+        for (int i = 0; i < 20; ++i) {
+            team.Run(new Task(task_func));
+        }
+        team.Wait();
+    }
+    
+    assert(counter == 20);
+    std::cout << "  Passed (counter: " << counter << ")." << std::endl;
+}
+
+int main() {
+    TestTaskTeam();
+    std::cout << "All Team tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/ThreadsTest.cpp

@@ -0,0 +1,72 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <atomic>
+#include <cassert>
+
+using namespace uLib;
+
+class MyThread : public Thread {
+public:
+    MyThread() : counter(0) {}
+    void Run() override {
+        for (int i = 0; i < 5; ++i) {
+            counter++;
+            Thread::Sleep(10);
+        }
+    }
+    std::atomic<int> counter;
+};
+
+void TestBasicThread() {
+    std::cout << "Testing basic Thread lifecycle..." << std::endl;
+    MyThread t;
+    assert(!t.IsRunning());
+    t.Start();
+    assert(t.IsRunning());
+    t.Join();
+    assert(!t.IsRunning());
+    assert(t.counter == 5);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestThreadDetach() {
+    std::cout << "Testing Thread Detach..." << std::endl;
+    std::atomic<bool> done(false);
+    
+    // Using a lambda or a simple subclass
+    class DetachedThread : public Thread {
+    public:
+        DetachedThread(std::atomic<bool>& d) : m_done(d) {}
+        void Run() override {
+            Thread::Sleep(50);
+            m_done = true;
+        }
+        std::atomic<bool>& m_done;
+    };
+    
+    {
+        DetachedThread* t = new DetachedThread(done);
+        t->Start();
+        t->Detach();
+        // The thread object 't' is still alive here, 
+        // but it will be destroyed soon if we delete it.
+        // For a detached thread using members, we MUST keep it alive.
+        
+        int wait_count = 0;
+        while(!done && wait_count < 20) {
+            Thread::Sleep(10);
+            wait_count++;
+        }
+        delete t;
+    }
+    
+    assert(done);
+    std::cout << "  Passed." << std::endl;
+}
+
+int main() {
+    TestBasicThread();
+    TestThreadDetach();
+    std::cout << "All Thread tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/testing-prototype.h

@@ -33,5 +33,7 @@ printf("..:: Testing " #name " ::..\n");
 
 #define TEST1(val) _fail += (val)==0
 #define TEST0(val) _fail += (val)!=0
+#define ASSERT_EQUAL(a,b) if((a)!=(b)) { printf("Assertion failed: " #a " != " #b " at line %d\n", __LINE__); _fail++; }
+#define ASSERT_NOT_NULL(ptr) if((ptr)==NULL) { printf("Assertion failed: " #ptr " is NULL at line %d\n", __LINE__); _fail++; }
 #define END_TESTING return _fail;
 

src/HEP/Detectors/DetectorChamber.cpp

@@ -1,4 +1,5 @@
 #include "HEP/Detectors/DetectorChamber.h"
+#include "Core/ObjectFactory.h"
 #include <cmath>
 
 namespace uLib {
@@ -14,14 +15,7 @@ MuonEvent DetectorChamber::ProjectMuonEvent(const MuonEvent &muon) const {
   HPoint3f X_in = muon.LineIn().origin;
   HPoint3f X_out = muon.LineOut().origin;
 
-  // Calculate squared distances to the plane normal point for comparison
-  // Actually, we should probably follow the user's description literally:
-  // "closest ... with the projection plane ( so the colsest direction point with the point of the normal defining the plane )"
-  // This could mean point-to-plane or point-to-point. 
-  // Given "closest with the projection plane", point-to-plane is more natural.
-  // However, "closest direction point with the point of the normal" strongly suggests point-to-point distance.
-  // Let's use distance to the plane for the first part and keep the logic consistent.
-  
+  // Let's use distance to the plane for the first part and keep the logic consistent.  
   float dist_in = std::abs((X_in - P).dot(N));
   float dist_out = std::abs((X_out - P).dot(N));
 
@@ -50,4 +44,6 @@ MuonEvent DetectorChamber::ProjectMuonEvent(const MuonEvent &muon) const {
   return projectedMuon;
 }
 
+ULIB_REGISTER_OBJECT(DetectorChamber)
+
 } // namespace uLib

src/HEP/Detectors/DetectorChamber.h

@@ -39,11 +39,11 @@ namespace uLib {
 
 
 class DetectorChamber : public ContainerBox {
-
-  typedef ContainerBox BaseClass;
   
-
 public:
+  uLibTypeMacro(DetectorChamber, ContainerBox)
+
+  
 
   DetectorChamber() : BaseClass() {
     m_ProjectionPlane.origin = HPoint3f(0, 0, 0);
@@ -65,7 +65,9 @@ public:
     HLine3f worldPlane;
     Matrix4f M = this->GetWorldMatrix();
     worldPlane.origin = M * m_ProjectionPlane.origin;
-    worldPlane.direction = M * m_ProjectionPlane.direction;
+    HVector3f dirNorm = M * m_ProjectionPlane.direction;
+    dirNorm.normalize(); // Normalize for consistent dot products
+    worldPlane.direction = dirNorm;
     return worldPlane;
   }
 

src/HEP/Geant/ActionInitialization.cpp

@@ -5,34 +5,37 @@
 namespace uLib {
 namespace Geant {
 
-ActionInitialization::ActionInitialization(EmitterPrimary *emitter,
-                                           Vector<GeantEvent> *output)
+ActionInitialization::ActionInitialization(EmitterPrimary *emitter, SimulationContext *context)
     : G4VUserActionInitialization(),
       m_Emitter(emitter),
-      m_Output(output)
+      m_Context(context)
 {}
 
 ActionInitialization::~ActionInitialization() {}
+  
+// Lightweight wrapper to avoid double-free in Geant4 EventManager
+class SteppingActionWrapper : public G4UserSteppingAction {
+public:
+  SteppingActionWrapper(SteppingAction *real) : m_Real(real) {}
+  virtual void UserSteppingAction(const G4Step* step) override { m_Real->UserSteppingAction(step); }
+private:
+  SteppingAction *m_Real;
+};
 
-void ActionInitialization::BuildForMaster() const {
-  // Master thread: no per-event actions needed
-}
+void ActionInitialization::BuildForMaster() const {}
 
 void ActionInitialization::Build() const {
-  // Register the primary generator
   if (m_Emitter) {
-    SetUserAction(m_Emitter);
+    SetUserAction(m_Emitter->Clone());
   } else {
-    // Fallback: default EmitterPrimary
     SetUserAction(new EmitterPrimary());
   }
-
-  // Register actions
-  if (m_Output) {
-    SteppingAction *sa = new SteppingAction(m_Output);
-    SetUserAction(static_cast<G4UserSteppingAction*>(sa));
-    SetUserAction(static_cast<G4UserEventAction*>(sa));
-  }
+  
+  SteppingAction *sa = new SteppingAction(m_Context);
+  // EventManager will delete sa via this slot
+  SetUserAction(static_cast<G4UserEventAction*>(sa));
+  // EventManager will delete the wrapper, leaving sa alive to be deleted once.
+  SetUserAction(new SteppingActionWrapper(sa));
 }
 
 } // namespace Geant

src/HEP/Geant/ActionInitialization.hh

@@ -2,31 +2,24 @@
 #define ActionInitialization_h
 
 #include "G4VUserActionInitialization.hh"
-#include "Core/Vector.h"
+#include "SimulationContext.h"
 
 namespace uLib {
 namespace Geant {
 
 class EmitterPrimary;
-class GeantEvent;
 
 class ActionInitialization : public G4VUserActionInitialization {
 public:
-  /// @param emitter  the primary generator to use (owned by caller)
-  /// @param output   pointer to the results vector (owned by caller)
-  ActionInitialization(EmitterPrimary *emitter = nullptr,
-                       Vector<GeantEvent> *output = nullptr);
+  ActionInitialization(EmitterPrimary *emitter, SimulationContext *context);
   ~ActionInitialization();
-
-  // Metodo chiamato solo dal thread principale (Master)
-  virtual void BuildForMaster() const;
-
-  // Metodo chiamato dai thread di lavoro (Worker) o in modalità sequenziale
-  virtual void Build() const;
+  
+  virtual void BuildForMaster() const override;
+  virtual void Build() const override;
 
 private:
-  EmitterPrimary *m_Emitter;
-  Vector<GeantEvent> *m_Output;
+  EmitterPrimary    *m_Emitter;
+  SimulationContext *m_Context;
 };
 
 } // namespace Geant

src/HEP/Geant/CMakeLists.txt

@@ -20,12 +20,15 @@ set(HEADERS
     PhysicsList.hh
     ActionInitialization.hh
     SteppingAction.hh
+    SimulationContext.h
 )
 
 set(SOURCES
     Scene.cpp
     Solid.cpp
     EmitterPrimary.cpp
+    Matter.cpp
+    GeantRegistration.cpp
     DetectorConstruction.cpp
     PhysicsList.cpp
     ActionInitialization.cpp

src/HEP/Geant/DetectorActionInitialization.cpp

@@ -0,0 +1,53 @@
+#include "DetectorActionInitialization.hh"
+#include "EmitterPrimary.hh"
+#include "DetectorSteppingAction.hh"
+
+namespace uLib {
+namespace Geant {
+
+DetectorActionInitialization::DetectorActionInitialization(EmitterPrimary *emitter,
+                                                           Vector<MuonEvent> *output,
+                                                           const Vector<HLine3f> &planes,
+                                                           int verbosity)
+    : G4VUserActionInitialization(),
+      m_Emitter(emitter),
+      m_Output(output),
+      m_Planes(planes),
+      m_Verbosity(verbosity)
+{}
+
+DetectorActionInitialization::~DetectorActionInitialization() {}
+  
+class DetectorSteppingActionWrapper : public G4UserSteppingAction {
+public:
+  DetectorSteppingActionWrapper(DetectorSteppingAction *real) : m_Real(real) {}
+  virtual void UserSteppingAction(const G4Step* step) override { m_Real->UserSteppingAction(step); }
+private:
+  DetectorSteppingAction *m_Real;
+};
+
+void DetectorActionInitialization::BuildForMaster() const {}
+
+void DetectorActionInitialization::Build() const {
+  if (m_Verbosity > 0) {
+      std::cout << "[Geant] Worker thread Building actions... Output ptr: " << m_Output 
+                << ", Planes count: " << m_Planes.size() << std::endl;
+  }
+  if (m_Emitter) {
+    SetUserAction(m_Emitter->Clone());
+  } else {
+    SetUserAction(new EmitterPrimary());
+  }
+
+  if (m_Output) {
+    DetectorSteppingAction *sa = new DetectorSteppingAction(m_Output, m_Planes);
+    sa->SetVerbosity(m_Verbosity);
+    // EventManager will delete sa via the Event slot
+    SetUserAction(static_cast<G4UserEventAction*>(sa));
+    // EventManager will delete the wrapper, leaving sa alive for the other deletion.
+    SetUserAction(new DetectorSteppingActionWrapper(sa));
+  }
+}
+
+} // namespace Geant
+} // namespace uLib

src/HEP/Geant/DetectorActionInitialization.hh

@@ -0,0 +1,35 @@
+#ifndef U_GEANT_DETECTORACTIONINITIALIZATION_HH
+#define U_GEANT_DETECTORACTIONINITIALIZATION_HH
+
+#include "G4VUserActionInitialization.hh"
+#include "Core/Vector.h"
+#include "HEP/Detectors/MuonEvent.h"
+#include "Math/Dense.h"
+
+namespace uLib {
+namespace Geant {
+
+class EmitterPrimary;
+
+class DetectorActionInitialization : public G4VUserActionInitialization {
+public:
+  DetectorActionInitialization(EmitterPrimary *emitter,
+                               Vector<MuonEvent> *output,
+                               const Vector<HLine3f> &planes,
+                               int verbosity = 0);
+  ~DetectorActionInitialization();
+
+  virtual void BuildForMaster() const override;
+  virtual void Build() const override;
+
+private:
+  EmitterPrimary *m_Emitter;
+  Vector<MuonEvent> *m_Output;
+  Vector<HLine3f> m_Planes;
+  int m_Verbosity;
+};
+
+} // namespace Geant
+} // namespace uLib
+
+#endif

src/HEP/Geant/DetectorSteppingAction.cpp

@@ -0,0 +1,110 @@
+#include "DetectorSteppingAction.hh"
+#include <Geant4/G4Step.hh>
+#include <Geant4/G4Track.hh>
+#include <Geant4/G4Event.hh>
+#include <Geant4/G4SystemOfUnits.hh>
+#include <cmath>
+#include <mutex>
+#include <iostream>
+
+static std::mutex g_DetectorOutputMutex;
+
+namespace uLib {
+namespace Geant {
+
+DetectorSteppingAction::DetectorSteppingAction(Vector<MuonEvent> *output, const Vector<HLine3f> &planes)
+    : G4UserSteppingAction(),
+      G4UserEventAction(),
+      m_Output(output),
+      m_Planes(planes),
+      m_CrossCount(0),
+      m_Verbosity(1)
+{
+    // std::cout << "[Geant] SteppingAction created with " << m_Planes.size() << " planes." << std::endl;
+}
+
+DetectorSteppingAction::~DetectorSteppingAction() {}
+
+void DetectorSteppingAction::BeginOfEventAction(const G4Event* /*event*/) {
+    m_CrossCount = 0;
+    
+    // Initialize with NaN
+    float nan = std::numeric_limits<float>::quiet_NaN();
+    m_Current.LineIn().origin = HPoint3f(nan, nan, nan);
+    m_Current.LineIn().direction = HVector3f(nan, nan, nan);
+    m_Current.LineOut().origin = HPoint3f(nan, nan, nan);
+    m_Current.LineOut().direction = HVector3f(nan, nan, nan);
+    m_Current.Momentum() = nan;
+}
+
+void DetectorSteppingAction::EndOfEventAction(const G4Event* /*event*/) {
+    if (m_Output) {
+        std::lock_guard<std::mutex> lock(g_DetectorOutputMutex);
+        m_Output->push_back(m_Current);
+    }
+}
+
+void DetectorSteppingAction::UserSteppingAction(const G4Step *step) {
+  if (!step) return;
+  if (!m_Output) {
+      return;
+  }
+
+  const G4Track *track = step->GetTrack();
+  if (!track) return;
+
+  static size_t step_count = 0;
+  if (++step_count % 1000 == 0 && m_Verbosity > 0) {
+      std::cout << "[GeantMT] Processed " << step_count << " total steps across events." << std::endl;
+  }
+
+  // Only consider primary muons
+  if (track->GetParentID() != 0) return;
+
+  // Track the momentum at generation/first step if not set
+  if (std::isnan(m_Current.Momentum())) {
+      m_Current.Momentum() = static_cast<Scalarf>(track->GetMomentum().mag() / MeV);
+  }
+
+  G4ThreeVector p1 = step->GetPreStepPoint()->GetPosition();
+  G4ThreeVector p2 = step->GetPostStepPoint()->GetPosition();
+  G4ThreeVector dir_g4 = track->GetMomentumDirection();
+  
+  HPoint3f p1f(p1.x(), p1.y(), p1.z());
+  HPoint3f p2f(p2.x(), p2.y(), p2.z());
+  HVector3f dirf(dir_g4.x(), dir_g4.y(), dir_g4.z());
+
+  // Check intersection with each detector plane
+  for (const auto& plane : m_Planes) {
+      // Plane: origin=O, direction=N (normal)
+      HPoint3f O = plane.origin;
+      HVector3f N = plane.direction;
+
+      float d1 = (p1f - O).dot(N);
+      float d2 = (p2f - O).dot(N);
+
+      // Check if the step crossed the plane
+      if ((d1 > 0 && d2 <= 0) || (d1 < 0 && d2 >= 0)) {
+          // Intersection point t = d1 / (d1 - d2)
+          float t = d1 / (d1 - d2);
+          HPoint3f intersection = p1f + t * (p2f - p1f);
+
+          if (m_CrossCount == 0) {
+              m_Current.LineIn().origin = intersection;
+              m_Current.LineIn().direction = dirf;
+              m_CrossCount++;
+              if (m_Verbosity > 0) std::cout << "[GeantMT] Hit first plane at " << intersection.transpose() << std::endl;
+          } else if (m_CrossCount == 1) {
+              m_Current.LineOut().origin = intersection;
+              m_Current.LineOut().direction = dirf;
+              m_CrossCount++;
+              if (m_Verbosity > 0) std::cout << "[GeantMT] Hit second plane at " << intersection.transpose() << std::endl;
+          }
+          // We break to avoid crossing multiple planes in one infinitesimal step (unlikely but possible)
+          // Actually, we should check ALL planes.
+      }
+  }
+}
+
+} // namespace Geant
+} // namespace uLib

src/HEP/Geant/DetectorSteppingAction.hh

@@ -0,0 +1,36 @@
+#ifndef U_GEANT_DETECTORSTEPPINGACTION_HH
+#define U_GEANT_DETECTORSTEPPINGACTION_HH
+
+#include "G4UserSteppingAction.hh"
+#include "G4UserEventAction.hh"
+#include "Core/Vector.h"
+#include "HEP/Detectors/MuonEvent.h"
+#include "HEP/Detectors/DetectorChamber.h"
+#include <mutex>
+
+namespace uLib {
+namespace Geant {
+
+class DetectorSteppingAction : public G4UserSteppingAction, public G4UserEventAction {
+public:
+  DetectorSteppingAction(Vector<MuonEvent> *output, const Vector<HLine3f> &planes);
+  virtual ~DetectorSteppingAction();
+
+  virtual void UserSteppingAction(const G4Step *step) override;
+  virtual void BeginOfEventAction(const G4Event *event) override;
+  virtual void EndOfEventAction(const G4Event *event) override;
+
+  void SetVerbosity(int level) { m_Verbosity = level; }
+
+private:
+  Vector<MuonEvent> *m_Output;
+  Vector<HLine3f> m_Planes; // World projection planes
+  MuonEvent m_Current;
+  int m_CrossCount = 0;
+  int m_Verbosity = 0;
+};
+
+} // namespace Geant
+} // namespace uLib
+
+#endif

src/HEP/Geant/EmitterPrimary.cpp

@@ -10,6 +10,10 @@
 #include "G4SystemOfUnits.hh"
 #include "Randomize.hh"
 
+#include "EcoMug.hh"
+#include "Math/Cylinder.h"
+
+
 namespace uLib {
 namespace Geant {
 
@@ -57,7 +61,169 @@ void EmitterPrimary::GeneratePrimaries(G4Event *anEvent) {
   fParticleGun->GeneratePrimaryVertex(anEvent);
 }
 
+EmitterPrimary* EmitterPrimary::Clone() const {
+  auto* clone = new EmitterPrimary();
+  clone->SetMatrix(this->GetMatrix());
+  return clone;
+}
+
 // -------------------------------------------------------------------------- //
+// SkyPlaneEmitterPrimary using EcoMug
+
+SkyPlaneEmitterPrimary::SkyPlaneEmitterPrimary()
+    : EmitterPrimary(), m_EcoMug(new EcoMug()), m_Size(1000.0, 1000.0) {
+    // Initial configuration for EcoMug in sky mode
+    m_EcoMug->SetUseSky();
+    m_EcoMug->SetSkySize({m_Size(0)/1000.0, m_Size(1)/1000.0});
+}
+
+SkyPlaneEmitterPrimary::~SkyPlaneEmitterPrimary() {
+    delete m_EcoMug;
+}
+
+void SkyPlaneEmitterPrimary::SetSkySize(const uLib::Vector2f& size) {
+    m_Size = size;
+    // EcoMug units are in meters (m=1), Geant4 units are in mm.
+    m_EcoMug->SetSkySize({m_Size(0)/1000.0, m_Size(1)/1000.0});
+    this->Updated();
+}
+
+void SkyPlaneEmitterPrimary::SetPlane(const uLib::Vector3f& p0, const uLib::Vector3f& normal) {
+    this->SetPosition(p0);
+    // Orient the emitter so that local Z is the normal.
+    // This is useful for unconventional planes, though EcoMug sky is usually horizontal.
+    // If we want a truly 'sky' plane, it usually stays horizontal.
+    this->Updated();
+}
+
+void SkyPlaneEmitterPrimary::GeneratePrimaries(G4Event* anEvent) {
+    if (!m_EcoMug) return;
+    m_EcoMug->Generate();
+
+    // EcoMug position is relative to its internal sky center in meters.
+    // Our wrapper uses the AffineTransform for the overall positioning.
+    std::array<double, 3> pos_m = m_EcoMug->GetGenerationPosition();
+    G4ThreeVector local_pos(pos_m[0]*1000.0, pos_m[1]*1000.0, pos_m[2]*1000.0);
+
+    // EcoMug momentum (direction and magnitude in GeV/c)
+    double p_mag = m_EcoMug->GetGenerationMomentum();
+    double theta = m_EcoMug->GetGenerationTheta();
+    double phi = m_EcoMug->GetGenerationPhi();
+    
+    // EcoMug theta is generated in a way that PI means pointing down (-Z)
+    G4ThreeVector local_dir(
+        sin(theta) * cos(phi),
+        sin(theta) * sin(phi),
+        cos(theta)
+    );
+
+    // Transform local coordinates to world
+    Matrix4f world_mat = this->GetWorldMatrix();
+    Vector3f world_pos = (world_mat * Vector4f(local_pos.x(), local_pos.y(), local_pos.z(), 1.0)).head<3>();
+    Vector3f world_dir = (world_mat * Vector4f(local_dir.x(), local_dir.y(), local_dir.z(), 0.0)).head<3>().normalized();
+
+    // Set particle charge
+    G4ParticleTable *particleTable = G4ParticleTable::GetParticleTable();
+    G4String particleName = (m_EcoMug->GetCharge() > 0) ? "mu+" : "mu-";
+    fParticleGun->SetParticleDefinition(particleTable->FindParticle(particleName));
+
+    fParticleGun->SetParticlePosition(G4ThreeVector(world_pos(0), world_pos(1), world_pos(2)));
+    fParticleGun->SetParticleMomentumDirection(G4ThreeVector(world_dir(0), world_dir(1), world_dir(2)));
+    fParticleGun->SetParticleEnergy(p_mag * GeV);
+    
+    fParticleGun->GeneratePrimaryVertex(anEvent);
+}
+
+EmitterPrimary* SkyPlaneEmitterPrimary::Clone() const {
+    auto* clone = new SkyPlaneEmitterPrimary();
+    clone->SetSkySize(this->m_Size);
+    clone->SetMatrix(this->GetMatrix());
+    return clone;
+}
+ 
+// -------------------------------------------------------------------------- //
+// CylinderEmitterPrimary using EcoMug
+
+CylinderEmitterPrimary::CylinderEmitterPrimary()
+    : EmitterPrimary(), m_EcoMug(new EcoMug()), m_Radius(1000.0), m_Height(1000.0) {
+    m_EcoMug->SetUseCylinder();
+    m_EcoMug->SetCylinderRadius(m_Radius/1000.0);
+    m_EcoMug->SetCylinderHeight(m_Height/1000.0);
+    m_EcoMug->SetCylinderCenterPosition({0.0, 0.0, m_Height/2000.0});
+}
+
+CylinderEmitterPrimary::~CylinderEmitterPrimary() {
+    delete m_EcoMug;
+}
+
+void CylinderEmitterPrimary::SetRadius(float r) {
+    m_Radius = r;
+    m_EcoMug->SetCylinderRadius(m_Radius/1000.0);
+    this->Updated();
+}
+
+void CylinderEmitterPrimary::SetHeight(float h) {
+    m_Height = h;
+    m_EcoMug->SetCylinderHeight(m_Height/1000.0);
+    m_EcoMug->SetCylinderCenterPosition({0.0, 0.0, m_Height/2000.0});
+    this->Updated();
+}
+
+void CylinderEmitterPrimary::GeneratePrimaries(G4Event* anEvent) {
+    if (!m_EcoMug) return;
+    m_EcoMug->Generate();
+
+    std::array<double, 3> pos_m = m_EcoMug->GetGenerationPosition();
+    G4ThreeVector local_pos(pos_m[0]*1000.0, pos_m[1]*1000.0, pos_m[2]*1000.0);
+
+    double p_mag = m_EcoMug->GetGenerationMomentum();
+    double theta = m_EcoMug->GetGenerationTheta();
+    double phi = m_EcoMug->GetGenerationPhi();
+    
+    G4ThreeVector local_dir(
+        sin(theta) * cos(phi),
+        sin(theta) * sin(phi),
+        cos(theta)
+    );
+
+    Matrix4f world_mat = this->GetWorldMatrix();
+    Vector3f world_pos = (world_mat * Vector4f(local_pos.x(), local_pos.y(), local_pos.z(), 1.0)).head<3>();
+    Vector3f world_dir = (world_mat * Vector4f(local_dir.x(), local_dir.y(), local_dir.z(), 0.0)).head<3>().normalized();
+
+    G4ParticleTable *particleTable = G4ParticleTable::GetParticleTable();
+    G4String particleName = (m_EcoMug->GetCharge() > 0) ? "mu+" : "mu-";
+    fParticleGun->SetParticleDefinition(particleTable->FindParticle(particleName));
+
+    fParticleGun->SetParticlePosition(G4ThreeVector(world_pos(0), world_pos(1), world_pos(2)));
+    fParticleGun->SetParticleMomentumDirection(G4ThreeVector(world_dir(0), world_dir(1), world_dir(2)));
+    fParticleGun->SetParticleEnergy(p_mag * GeV);
+    
+    fParticleGun->GeneratePrimaryVertex(anEvent);
+}
+
+EmitterPrimary* CylinderEmitterPrimary::Clone() const {
+    auto* clone = new CylinderEmitterPrimary();
+    clone->SetRadius(this->m_Radius);
+    clone->SetHeight(this->m_Height);
+    clone->SetMatrix(this->GetMatrix());
+    return clone;
+}
+
+// -------------------------------------------------------------------------- //
+
+
+
+
+
+
+
+
+
+
+
+
+// -------------------------------------------------------------------------- //
+
 
 QuadMeshEmitterPrimary::QuadMeshEmitterPrimary()
     : EmitterPrimary(), m_Mesh(nullptr), m_TotalArea(0.0) {
@@ -153,6 +319,12 @@ void QuadMeshEmitterPrimary::GeneratePrimaries(G4Event *anEvent) {
     fParticleGun->GeneratePrimaryVertex(anEvent);
   }
 }
+EmitterPrimary* QuadMeshEmitterPrimary::Clone() const {
+  auto* clone = new QuadMeshEmitterPrimary();
+  if (m_Mesh) clone->SetMesh(m_Mesh);
+  clone->SetMatrix(this->GetMatrix());
+  return clone;
+}
 
 } // namespace Geant
 } // namespace uLib

src/HEP/Geant/EmitterPrimary.hh

@@ -4,10 +4,13 @@
 #include "G4VUserPrimaryGeneratorAction.hh"
 #include "globals.hh"
 
+
 namespace uLib {
 class QuadMesh;
 }
 
+class EcoMug;
+
 #include "Math/QuadMesh.h"
 #include "Core/Object.h"
 #include "Math/Transform.h"
@@ -16,12 +19,15 @@ class QuadMesh;
 class G4ParticleGun;
 class G4Event;
 
+
 namespace uLib {
 namespace Geant {
 
-class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public Object, public AffineTransform
+class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransform
 {
   public:
+    uLibTypeMacro(EmitterPrimary, Object)
+
     EmitterPrimary();    
     virtual ~EmitterPrimary();
 
@@ -29,16 +35,68 @@ class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public Object, publ
     virtual void GeneratePrimaries(G4Event*);         
 
     virtual void Updated() override { ULIB_SIGNAL_EMIT(EmitterPrimary::Updated); }
+    
+    /// Create a clone of this emitter for multi-threading
+    virtual EmitterPrimary* Clone() const;
 
   protected:
     G4ParticleGun* fParticleGun; // Puntatore al cannone di particelle
 };
 
+class SkyPlaneEmitterPrimary : public EmitterPrimary
+{
+  public:
+    uLibTypeMacro(SkyPlaneEmitterPrimary, EmitterPrimary)
+
+    SkyPlaneEmitterPrimary();
+    virtual ~SkyPlaneEmitterPrimary();
+
+    virtual void GeneratePrimaries(G4Event*);
+
+    void SetPlane(const uLib::Vector3f& p0, const uLib::Vector3f& normal);
+    void SetSkySize(const uLib::Vector2f& size);
+    uLib::Vector2f GetSkySize() const { return m_Size; }
+    
+    virtual EmitterPrimary* Clone() const override;
+
+  private:
+    EcoMug* m_EcoMug;
+    uLib::Vector2f m_Size;
+};
+
+class CylinderEmitterPrimary : public EmitterPrimary
+{
+  public:
+    uLibTypeMacro(CylinderEmitterPrimary, EmitterPrimary)
+
+    CylinderEmitterPrimary();
+    virtual ~CylinderEmitterPrimary();
+
+    virtual void GeneratePrimaries(G4Event*);
+
+    void SetRadius(float r);
+    float GetRadius() const { return m_Radius; }
+    void SetHeight(float h);
+    float GetHeight() const { return m_Height; }
+    
+    virtual EmitterPrimary* Clone() const override;
+
+  private:
+    EcoMug* m_EcoMug;
+    float m_Radius;
+    float m_Height;
+};
+
+
+
+
 
 
 class QuadMeshEmitterPrimary : public EmitterPrimary
 {
   public:
+    uLibTypeMacro(QuadMeshEmitterPrimary, EmitterPrimary)
+
     QuadMeshEmitterPrimary();    
     virtual ~QuadMeshEmitterPrimary();
 
@@ -46,6 +104,8 @@ class QuadMeshEmitterPrimary : public EmitterPrimary
     virtual void GeneratePrimaries(G4Event*);
 
     void SetMesh(uLib::QuadMesh* mesh);
+    
+    virtual EmitterPrimary* Clone() const override;
 
   private:
     uLib::QuadMesh* m_Mesh;

src/HEP/Geant/GeantEvent.h

@@ -26,6 +26,7 @@
 #ifndef U_GEANTEVENT_H
 #define U_GEANTEVENT_H
 
+#include "Core/Object.h"
 #include "Core/Types.h"
 #include "Core/Vector.h"
 #include "Math/Dense.h"
@@ -46,9 +47,10 @@ class SteppingAction;
 /// recording the change of momentum and direction at each step boundary.
 ///////////////////////////////////////////////////////////////////////////////
 
-class GeantEvent {
+class GeantEvent : public Object {
   
 public:
+  uLibTypeMacro(GeantEvent, Object)
 
   /// A single interaction step along the muon path.
   struct Delta {
@@ -73,6 +75,7 @@ public:
 
   void Print(const size_t size = 10) const;
 
+
 private:
   Id_t m_EventID;
   Scalarf m_Momentum;

src/HEP/Geant/GeantRegistration.cpp

@@ -0,0 +1,22 @@
+#include "Core/ObjectFactory.h"
+#include "HEP/Geant/Matter.h"
+#include "HEP/Geant/Solid.h"
+#include "HEP/Geant/Scene.h"
+#include "HEP/Geant/EmitterPrimary.hh"
+#include "HEP/Geant/GeantEvent.h"
+
+namespace uLib {
+namespace Geant {
+
+ULIB_REGISTER_OBJECT(Material)
+ULIB_REGISTER_OBJECT(Solid)
+ULIB_REGISTER_OBJECT(TessellatedSolid)
+ULIB_REGISTER_OBJECT(BoxSolid)
+ULIB_REGISTER_OBJECT(Scene)
+ULIB_REGISTER_OBJECT(SkyPlaneEmitterPrimary)
+ULIB_REGISTER_OBJECT(CylinderEmitterPrimary)
+ULIB_REGISTER_OBJECT(QuadMeshEmitterPrimary)
+ULIB_REGISTER_OBJECT(GeantEvent)
+
+} // namespace Geant
+} // namespace uLib

src/HEP/Geant/Matter.cpp

@@ -0,0 +1,21 @@
+
+#include "HEP/Geant/Matter.h"
+#include <Geant4/G4Material.hh>
+#include <Geant4/G4NistManager.hh>
+
+using namespace uLib::Geant;
+
+Material::Material() : m_G4Data(nullptr) {}
+
+Material::Material(const char *name) : m_G4Data(nullptr) {
+    this->SetFromNist(name);
+}
+
+Material::~Material() {
+    if(m_G4Data) delete m_G4Data;
+}
+
+void Material::SetFromNist(const char *name) {
+    G4NistManager* man = G4NistManager::Instance();
+    m_G4Data = man->FindOrBuildMaterial(name);
+}

src/HEP/Geant/Matter.h

@@ -29,9 +29,10 @@
 #define MATTER_H
 
 #include "Core/Object.h"
+#include <Geant4/G4Material.hh>
+#include <Geant4/G4NistManager.hh>
 
 class G4Element;
-class G4Material;
 
 namespace uLib {
 namespace Geant {
@@ -55,17 +56,54 @@ private:
 //// MATERIAL //////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
+// TODO: finish from G4NistMaterialBuilder
 
 class Material : public Object {
 public:
+    uLibTypeMacro(Material, Object)
+
+    enum State  {
+        Undefined = 0,
+        Solid,
+        Liquid,
+        Gas
+    };
+
+    Material();
+    Material(const char *name);
+    ~Material();
+
+    void SetFromNist(const char *name);
+
+    template <typename Ar>
+    void serialize(Ar &ar) {
+        ar & HRP("name", m_G4Data->GetName());
+        ar & HRP("density", m_G4Data->GetDensity());
+        ar & serialization::make_hrp_enum("state", m_G4Data->GetState(), {"Undefined", "Solid", "Liquid", "Gas"});
+    }
+    
+    G4Material *GetG4Material() { return m_G4Data; }
 
-    uLibRefMacro(G4Data,G4Material *)
 private:
     G4Material *m_G4Data;
+
 };
 
+// class MaterialCompound : public Material {
+// public:
 
-
+//     MaterialCompound(const char *name) {}
+        
+//     void AddMaterial(Material *m, double fractionmass) { m_Materials.push_back(std::make_pair(m, fractionmass)); }
+//     void AddElement(Element *e, double fractionmass) { m_Elements.push_back(std::make_pair(e, fractionmass)); }
+//     void SetDensity(double density) { m_Density = density; }
+    
+// private:
+//     std::vector<std::pair<Material *, double>> m_Materials;
+//     std::vector<std::pair<Element *, double>> m_Elements;
+//     double m_Density;
+// };
+    
 }
 }
 

src/HEP/Geant/Scene.cpp

@@ -1,28 +1,3 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
 #include <Geant4/G4Box.hh>
 #include <Geant4/G4LogicalVolume.hh>
 #include <Geant4/G4Material.hh>
@@ -42,13 +17,15 @@
 #include "Scene.h"
 #include "PhysicsList.hh"
 #include "ActionInitialization.hh"
+#include "SimulationContext.h"
+#include "HEP/Detectors/DetectorChamber.h"
 
 namespace uLib {
 namespace Geant {
 
 class SceneDetectorConstruction : public DetectorConstruction {
 public:
-  SceneDetectorConstruction(class SceneImpl *owner);
+  SceneDetectorConstruction(class SceneImpl *owner) : DetectorConstruction("Scene"), m_Owner(owner) {}
   G4VPhysicalVolume *Construct() override;
 private:
   class SceneImpl *m_Owner;
@@ -69,53 +46,50 @@ static void CheckGeant4Environment() {
 
 class SceneImpl {
 public:
-  // constructor //
   SceneImpl() : m_RunManager(G4RunManagerFactory::CreateRunManager(G4RunManagerType::Serial)),
                 m_Emitter(nullptr),
-                m_Output(nullptr) {
+                m_InitCalled(false) {
     m_RunManager->SetUserInitialization(new PhysicsList);
   }
 
-  // destructor //
   ~SceneImpl() { 
     if (m_RunManager) delete m_RunManager; 
-    if (m_World) delete m_World; 
+    // m_World deletion is handled in Scene destructor or here
   }
 
   void Initialize() {
-    // Set mandatory initialization classes for Geant4
+    if (m_InitCalled) return;
+    
     m_RunManager->SetUserInitialization(new SceneDetectorConstruction(this));
-    m_RunManager->SetUserInitialization(
-        new ActionInitialization(m_Emitter, m_Output));
-
-    // Initialize Geant4
+    m_RunManager->SetUserInitialization(new ActionInitialization(m_Emitter, &m_Context));
+    
     m_RunManager->Initialize();
+    m_InitCalled = true;
   }
 
-  // members //
   Vector<Solid *> m_Solids;
   Solid *m_World = nullptr;
   ContainerBox m_WorldBox;
   G4RunManager *m_RunManager;
   EmitterPrimary *m_Emitter;
-  Vector<GeantEvent> *m_Output;
+  SimulationContext m_Context;
+  bool m_InitCalled;
 };
 
-SceneDetectorConstruction::SceneDetectorConstruction(SceneImpl *owner) 
-  : DetectorConstruction("Scene"), m_Owner(owner) {}
-
 G4VPhysicalVolume *SceneDetectorConstruction::Construct() {
   return m_Owner->m_World->GetPhysical();
 }
 
-
-
-
 Scene::Scene() {
   CheckGeant4Environment();
   d = new SceneImpl();
 }
-Scene::~Scene() { delete d; }
+
+Scene::~Scene() {
+    // Delete solids
+    for(auto s : d->m_Solids) delete s; 
+    delete d;
+}
 
 void Scene::AddSolid(Solid *solid, Solid *parent) { 
   d->m_Solids.push_back(solid);
@@ -127,12 +101,10 @@ void Scene::AddSolid(Solid *solid, Solid *parent) {
 }
 
 const Solid* Scene::GetWorld() const { return d->m_World; }
-
 ContainerBox* Scene::GetWorldBox() const { return &d->m_WorldBox; }
+const Vector<Solid*>& Scene::GetSolids() const { return d->m_Solids; }
 
 void Scene::ConstructWorldBox(const Vector3f &size, const char *material) {
-  // Get nist material manager
-
   d->m_WorldBox.Scale(size);
   d->m_WorldBox.SetPosition(-size/2.0f);
 
@@ -142,54 +114,48 @@ void Scene::ConstructWorldBox(const Vector3f &size, const char *material) {
     AddSolid(d->m_World);
   }
 
-  G4Box *solidWorld = new G4Box("World", 
-                                0.5 * size(0), 
-                                0.5 * size(1),
-                                0.5 * size(2));
-
-  G4LogicalVolume *logicWorld = new G4LogicalVolume(solidWorld,
-                                                    d->m_World->GetMaterial(),
-                                                    d->m_World->GetName());
-
+  G4Box *solidWorld = new G4Box("World", 0.5 * size(0), 0.5 * size(1), 0.5 * size(2));
+  G4LogicalVolume *logicWorld = new G4LogicalVolume(solidWorld, d->m_World->GetMaterial(), d->m_World->GetName());
   d->m_World->SetLogical(logicWorld);
   
-  G4PVPlacement *physWorld = new G4PVPlacement(
-    nullptr,
-    G4ThreeVector(0, 0, 0),
-    logicWorld,
-    d->m_World->GetName(),
-    0,
-    false,
-    0,
-    true);
-
+  G4PVPlacement *physWorld = new G4PVPlacement(nullptr, G4ThreeVector(0, 0, 0), logicWorld, d->m_World->GetName(), 0, false, 0, true);
   d->m_World->SetPhysical(physWorld);
-
-  // no transforms are allowed for the world box
-  // Matrix4f transform = box->GetMatrix(); 
-  // d->m_World->SetTransform(transform);
 }
 
-void Scene::SetEmitter(EmitterPrimary *emitter) {
-  d->m_Emitter = emitter;
-}
-
-void Scene::Initialize() {
-  d->Initialize();
+void Scene::SetEmitter(EmitterPrimary *emitter) { d->m_Emitter = emitter; }
+void Scene::Initialize() { d->Initialize(); }
+void Scene::SetVerbosity(int level) {
+  d->m_Context.verbosity = level;
+  if (d->m_RunManager) d->m_RunManager->SetVerboseLevel(level);
 }
 
 void Scene::RunSimulation(int nEvents, Vector<GeantEvent> &results) {
-  d->m_Output = &results;
+  d->Initialize(); // Ensure initialized
+  d->m_Context.mode = SimulationMode::DETAILED;
+  d->m_Context.outputGeant = &results;
+  d->m_Context.outputMuon = nullptr;
+  
+  d->m_RunManager->BeamOn(nEvents);
+}
 
-  // Re-initialize ActionInitialization with the output buffer
-  // (ActionInitialization was already set during Initialize, but we need
-  //  to ensure the output pointer is current)
-  d->m_RunManager->SetUserInitialization(
-      new ActionInitialization(d->m_Emitter, &results));
+void Scene::RunDetectorSimulation(int nEvents, Vector<MuonEvent> &results) {
+  d->Initialize(); // Ensure initialized
+  d->m_Context.mode = SimulationMode::DETECTOR;
+  d->m_Context.outputGeant = nullptr;
+  d->m_Context.outputMuon = &results;
+  
+  // Find detector planes
+  d->m_Context.detectorPlanes.clear();
+  for (Solid* s : d->m_Solids) {
+      if (BoxSolid* bs = dynamic_cast<BoxSolid*>(s)) {
+          if (DetectorChamber* dc = dynamic_cast<DetectorChamber*>(bs->GetObject())) {
+              d->m_Context.detectorPlanes.push_back(dc->GetWorldProjectionPlane());
+          }
+      }
+  }
 
   d->m_RunManager->BeamOn(nEvents);
 }
 
 } // namespace Geant
 } // namespace uLib
-

src/HEP/Geant/Scene.h

@@ -32,6 +32,7 @@
 #include "Core/Vector.h"
 #include "Solid.h"
 #include "GeantEvent.h"
+#include "HEP/Detectors/MuonEvent.h"
 
 class G4VPhysicalVolume;
 
@@ -42,6 +43,8 @@ class EmitterPrimary;
 
 class Scene : public Object {
 public:
+  uLibTypeMacro(Scene, Object)
+
   Scene();
   ~Scene();
 
@@ -54,17 +57,26 @@ public:
   
   ContainerBox* GetWorldBox() const;
 
+  /// Get the list of solids in the scene
+  const Vector<Solid*>& GetSolids() const;
+
   /// Set the primary generator (emitter) for the simulation.
   /// The Scene does NOT take ownership of the emitter.
   void SetEmitter(EmitterPrimary *emitter);
 
   /// Initialize the Geant4 run manager with detector, physics, and action.
   void Initialize();
+  
+  /// Set the verbosity level for console output (default 0)
+  void SetVerbosity(int level);
 
   /// Run the simulation for nEvents muons.
   /// Results are appended to the provided vector.
   void RunSimulation(int nEvents, Vector<GeantEvent> &results);
 
+  /// Specialized detector simulation trackingMuonEvent line crossings.
+  void RunDetectorSimulation(int nEvents, Vector<MuonEvent> &results);
+
 private:
   class SceneImpl *d;
 };

src/HEP/Geant/SimulationContext.h

@@ -0,0 +1,30 @@
+#ifndef U_GEANT_SIMULATIONCONTEXT_H
+#define U_GEANT_SIMULATIONCONTEXT_H
+
+#include "Core/Vector.h"
+#include "GeantEvent.h"
+#include "HEP/Detectors/MuonEvent.h"
+#include "Math/Dense.h"
+#include <mutex>
+
+namespace uLib {
+namespace Geant {
+
+enum class SimulationMode {
+    DETAILED,
+    DETECTOR
+};
+
+struct SimulationContext {
+    SimulationMode mode = SimulationMode::DETAILED;
+    Vector<GeantEvent> *outputGeant = nullptr;
+    Vector<MuonEvent> *outputMuon = nullptr;
+    Vector<HLine3f> detectorPlanes;
+    int verbosity = 0;
+    std::mutex outputMutex;
+};
+
+} // namespace Geant
+} // namespace uLib
+
+#endif

src/HEP/Geant/Solid.cpp

@@ -85,7 +85,7 @@ void Solid::SetMaterial(G4Material *material) {
 }
 
 void Solid::SetTransform(Matrix4f transform) {
-  uLib::AffineTransform t;
+    uLib::AffineTransform t;
   t.SetMatrix(transform);
 
     // 2. Extract position and rotation for Geant4
@@ -146,11 +146,15 @@ void Solid::SetParent(Solid *parent) {
 
 
 
+TessellatedSolid::TessellatedSolid() 
+    : BaseClass("unnamed_tessellated"), m_Solid(new G4TessellatedSolid("unnamed_tessellated")) {}
+
 TessellatedSolid::TessellatedSolid(const char *name)
     : BaseClass(name), m_Solid(new G4TessellatedSolid(name)) {
     }
 
 void TessellatedSolid::SetMesh(TriangleMesh &mesh) {
+  this->m_Mesh = mesh;
   G4TessellatedSolid *ts = this->m_Solid;
   for (int i = 0; i < mesh.Triangles().size(); ++i) {
     const Vector3i &trg = mesh.Triangles().at(i);
@@ -165,13 +169,22 @@ void TessellatedSolid::SetMesh(TriangleMesh &mesh) {
   }
 }
 
+void TessellatedSolid::Update() {
+}
 
 
 
 
+
+BoxSolid::BoxSolid(const char *name) : 
+    BaseClass(name), 
+    m_ContainerBox(new ContainerBox()), 
+    m_Solid(new G4Box(name, 1, 1, 1))
+  {}
+
 BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
-  m_Solid = new G4Box(name, 1,1,1);
-  m_Object = box;
+  m_Solid = new G4Box(name, 1, 1, 1);
+  m_ContainerBox = box;
   Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
   if (m_Logical) {
     m_Logical->SetSolid(m_Solid);
@@ -180,16 +193,16 @@ BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
 }
 
 void BoxSolid::Update() {
-  if (m_Object) {
-    Vector3f size = m_Object->GetSize();
+  if (m_ContainerBox) {
+    Vector3f size = m_ContainerBox->GetSize();
     m_Solid->SetXHalfLength(size(0) * 0.5);
     m_Solid->SetYHalfLength(size(1) * 0.5);
     m_Solid->SetZHalfLength(size(2) * 0.5);
     
     // Geant4 placement is relative to center. uLib Box is anchored at corner.
     // 1. Get position and rotation (clean, without scale)
-    Vector3f pos = m_Object->GetPosition();
-    Matrix3f rot = m_Object->GetRotation();
+    Vector3f pos = m_ContainerBox->GetPosition();
+    Matrix3f rot = m_ContainerBox->GetRotation();
 
     // 2. Center = Corner + Rotation * (Half-Size)
     // We must rotate the offset vector because uLib box can be rotated.
@@ -201,6 +214,9 @@ void BoxSolid::Update() {
     
     this->SetTransform(t.GetMatrix());
   }
+
+
+
 }
 
 

src/HEP/Geant/Solid.h

@@ -43,12 +43,15 @@ namespace Geant {
 
 class Solid : public Object {
 public:
+  uLibTypeMacro(Solid, Object)
+
   Solid();
   Solid(const char *name);
   virtual ~Solid();
 
   void SetNistMaterial(const char *name);
   void SetMaterial(G4Material *material);
+  
   void SetSizeUnit(const char *unit);
   // Implementiamo SetParent qui, per tutti.
   virtual void SetParent(Solid *parent); 
@@ -66,6 +69,14 @@ public:
     return m_Logical ? m_Logical->GetName().c_str() : m_Name.c_str(); 
   }
 
+  template < typename Ar >
+  void serialize(Ar &ar, const unsigned int version) {
+    ar & m_Name;
+  }
+    
+    
+
+
 protected:
 
   std::string m_Name;
@@ -81,17 +92,22 @@ protected:
 
 
 class TessellatedSolid : public Solid {
-  typedef Solid BaseClass;
 public:
+  uLibTypeMacro(TessellatedSolid, Solid)
+
+  TessellatedSolid();
   TessellatedSolid(const char *name);
   void SetMesh(TriangleMesh &mesh);
   uLibGetMacro(Solid, G4TessellatedSolid *) 
   virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
+  
+  const TriangleMesh& GetMesh() const { return m_Mesh; }
 
 public slots:
   void Update();
 
 private : 
+  TriangleMesh        m_Mesh;
   G4TessellatedSolid *m_Solid;
 };
 
@@ -101,20 +117,36 @@ private :
 
 
 class BoxSolid : public Solid {
-  typedef Solid BaseClass;
-
+  
 public:
+  uLibTypeMacro(BoxSolid, Solid)
+
+  BoxSolid(const char *name = "");
   BoxSolid(const char *name, ContainerBox *box);
   virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
+  
+  ContainerBox* GetObject() const { return m_ContainerBox; }
+
+  template < typename Ar >
+  void serialize(Ar &ar, const unsigned int version) {
+    ar & boost::serialization::base_object<BaseClass>(*this);
+    ar & m_ContainerBox;
+  }
 
 public slots:
   void Update();
 
 private:
-  ContainerBox *m_Object;
+  ContainerBox *m_ContainerBox;
   G4Box *m_Solid;
 };
 
+
+
+
+
+
+
 } // namespace Geant
 } // namespace uLib
 

src/HEP/Geant/SteppingAction.cpp

@@ -1,103 +1,124 @@
 #include "SteppingAction.hh"
-
-#include "G4Step.hh"
-#include "G4Track.hh"
-#include "G4Event.hh"
-#include "G4RunManager.hh"
-#include "G4LogicalVolume.hh"
-#include "G4SystemOfUnits.hh"
-#include "G4ParticleDefinition.hh"
+#include <Geant4/G4Step.hh>
+#include <Geant4/G4Track.hh>
+#include <Geant4/G4Event.hh>
+#include <Geant4/G4SystemOfUnits.hh>
 #include <set>
 #include <iostream>
+#include <mutex>
+#include <cmath>
 
 namespace uLib {
 namespace Geant {
 
-SteppingAction::SteppingAction(Vector<GeantEvent> *output)
+SteppingAction::SteppingAction(SimulationContext *context)
     : G4UserSteppingAction(),
-      m_Output(output),
-      m_Current(),
-      m_LastEventID(-1)
+      G4UserEventAction(),
+      m_Context(context),
+      m_Verbosity(0)
 {}
 
 SteppingAction::~SteppingAction() {}
 
 void SteppingAction::BeginOfEventAction(const G4Event *event) {
-  if (!event || !m_Output) return;
+  if (!event || !m_Context) return;
 
-  // Start a new GeantEvent
-  m_Current = GeantEvent();
-  m_Current.m_EventID = static_cast<Id_t>(event->GetEventID());
+  if (m_Context->mode == SimulationMode::DETAILED) {
+      m_CurrentGeant = GeantEvent();
+      m_CurrentGeant.m_EventID = static_cast<Id_t>(event->GetEventID());
 
-  // Set initial momentum and generation vector from primary vertex
-  if (event->GetNumberOfPrimaryVertex() > 0) {
-    G4PrimaryVertex *vtx = event->GetPrimaryVertex(0);
-    G4ThreeVector pos = vtx->GetPosition();
-    m_Current.m_GenVector.origin = HPoint3f(pos.x(), pos.y(), pos.z());
+      if (event->GetNumberOfPrimaryVertex() > 0) {
+        G4PrimaryVertex *vtx = event->GetPrimaryVertex(0);
+        G4ThreeVector pos = vtx->GetPosition();
+        m_CurrentGeant.m_GenVector.origin = HPoint3f(pos.x(), pos.y(), pos.z());
 
-    if (vtx->GetNumberOfParticle() > 0) {
-      G4PrimaryParticle *prim = vtx->GetPrimary(0);
-      G4ThreeVector mom = prim->GetMomentumDirection();
-      m_Current.m_GenVector.direction = HVector3f(mom.x(), mom.y(), mom.z());
-      m_Current.m_Momentum = static_cast<Scalarf>(prim->GetTotalMomentum() / MeV);
-    }
+        if (vtx->GetNumberOfParticle() > 0) {
+          G4PrimaryParticle *prim = vtx->GetPrimary(0);
+          G4ThreeVector mom = prim->GetMomentumDirection();
+          m_CurrentGeant.m_GenVector.direction = HVector3f(mom.x(), mom.y(), mom.z());
+          m_CurrentGeant.m_Momentum = static_cast<Scalarf>(prim->GetTotalMomentum() / MeV);
+        }
+      }
+  } else {
+      // Detector mode
+      m_MuonCrossCount = 0;
+      float nan = std::numeric_limits<float>::quiet_NaN();
+      m_CurrentMuon.LineIn().origin = HPoint3f(nan, nan, nan);
+      m_CurrentMuon.LineIn().direction = HVector3f(nan, nan, nan);
+      m_CurrentMuon.LineOut().origin = HPoint3f(nan, nan, nan);
+      m_CurrentMuon.LineOut().direction = HVector3f(nan, nan, nan);
+      m_CurrentMuon.Momentum() = nan;
   }
 }
 
 void SteppingAction::EndOfEventAction(const G4Event *event) {
-  if (m_Output && !m_Current.m_Path.empty()) {
-    std::cout << "[Geant] Finished Event " << m_Current.m_EventID 
-              << " with " << m_Current.m_Path.size() << " steps." << std::endl;
-    
-    // Check if we hit anything other than World
-    std::set<std::string> volumes;
-    for (const auto& delta : m_Current.m_Path) {
-      if (!delta.m_SolidName.empty()) volumes.insert(delta.m_SolidName);
-    }
-    if (volumes.size() > 1) {
-      std::cout << "        - Hit volumes: ";
-      for (const auto& v : volumes) std::cout << v << " ";
-      std::cout << std::endl;
-    }
+  if (!m_Context) return;
 
-    m_Output->push_back(m_Current);
+  if (m_Context->mode == SimulationMode::DETAILED && m_Context->outputGeant) {
+    if (!m_CurrentGeant.m_Path.empty()) {
+        std::lock_guard<std::mutex> lock(m_Context->outputMutex);
+        m_Context->outputGeant->push_back(m_CurrentGeant);
+    }
+  } else if (m_Context->mode == SimulationMode::DETECTOR && m_Context->outputMuon) {
+    // In detector mode, we always push the event (to keep indexing consistent) 
+    // or only if hit? User requested "all muon event line in and out ar at first set to nan".
+    // So we push everything.
+    std::lock_guard<std::mutex> lock(m_Context->outputMutex);
+    m_Context->outputMuon->push_back(m_CurrentMuon);
   }
 }
 
 void SteppingAction::UserSteppingAction(const G4Step *step) {
-  if (!step || !m_Output) return;
+  if (!step || !m_Context) return;
 
   const G4Track *track = step->GetTrack();
-  if (!track) return;
+  if (!track || track->GetParentID() != 0) return;
 
-  // Only record primary particle (muon)
-  if (track->GetParentID() != 0) return;
+  if (m_Context->mode == SimulationMode::DETAILED) {
+      GeantEvent::Delta delta;
+      delta.m_Length = static_cast<Scalarf>(step->GetStepLength() / mm);
+      delta.m_Momentum = static_cast<Scalarf>(track->GetMomentum().mag() / MeV);
+      G4ThreeVector dir = track->GetMomentumDirection();
+      delta.m_Direction = HVector3f(dir.x(), dir.y(), dir.z());
 
-  // Record a Delta for this step
-  GeantEvent::Delta delta;
+      if (track->GetVolume()) {
+          delta.m_SolidName = track->GetVolume()->GetName();
+      }
+      m_CurrentGeant.m_Path.push_back(delta);
+  } else {
+      // Detector Mode
+      if (std::isnan(m_CurrentMuon.Momentum())) {
+          m_CurrentMuon.Momentum() = static_cast<Scalarf>(track->GetMomentum().mag() / MeV);
+      }
 
-  // Step length
-  delta.m_Length = static_cast<Scalarf>(step->GetStepLength() / mm);
+      G4ThreeVector p1 = step->GetPreStepPoint()->GetPosition();
+      G4ThreeVector p2 = step->GetPostStepPoint()->GetPosition();
+      G4ThreeVector dir_g4 = track->GetMomentumDirection();
+      
+      HPoint3f p1f(p1.x(), p1.y(), p1.z());
+      HPoint3f p2f(p2.x(), p2.y(), p2.z());
+      HVector3f dirf(dir_g4.x(), dir_g4.y(), dir_g4.z());
 
-  // Post-step momentum
-  G4ThreeVector postMom = track->GetMomentum();
-  delta.m_Momentum = static_cast<Scalarf>(postMom.mag() / MeV);
+      for (const auto& plane : m_Context->detectorPlanes) {
+          float d1 = (p1f - plane.origin).dot(plane.direction);
+          float d2 = (p2f - plane.origin).dot(plane.direction);
 
-  // Post-step direction
-  G4ThreeVector dir = track->GetMomentumDirection();
-  delta.m_Direction = HVector3f(static_cast<float>(dir.x()),
-                                 static_cast<float>(dir.y()),
-                                 static_cast<float>(dir.z()));
+          if ((d1 > 0 && d2 <= 0) || (d1 < 0 && d2 >= 0)) {
+              float t = d1 / (d1 - d2);
+              HPoint3f intersection = p1f + t * (p2f - p1f);
 
-  // Solid name where the step occurred
-  const G4LogicalVolume *vol = track->GetVolume() 
-      ? track->GetVolume()->GetLogicalVolume() 
-      : nullptr;
-  if (vol) {
-    delta.m_SolidName = vol->GetName();
+              if (m_MuonCrossCount == 0) {
+                  m_CurrentMuon.LineIn().origin = intersection;
+                  m_CurrentMuon.LineIn().direction = dirf;
+                  m_MuonCrossCount++;
+              } else if (m_MuonCrossCount == 1) {
+                  m_CurrentMuon.LineOut().origin = intersection;
+                  m_CurrentMuon.LineOut().direction = dirf;
+                  m_MuonCrossCount++;
+              }
+          }
+      }
   }
-
-  m_Current.m_Path.push_back(delta);
 }
 
 } // namespace Geant

src/HEP/Geant/SteppingAction.hh

@@ -5,26 +5,30 @@
 #include "G4UserEventAction.hh"
 #include "Core/Vector.h"
 #include "GeantEvent.h"
+#include "HEP/Detectors/MuonEvent.h"
+#include "SimulationContext.h"
 
 namespace uLib {
 namespace Geant {
 
-/// SteppingAction collects scattering data at each Geant4 step and
-/// builds GeantEvent objects in the output buffer.
+/// SteppingAction collects scattering data at each Geant4 step.
 class SteppingAction : public G4UserSteppingAction, public G4UserEventAction {
 public:
-  /// @param output  pointer to the results vector owned by the Scene
-  SteppingAction(Vector<GeantEvent> *output);
+  SteppingAction(SimulationContext *context);
   virtual ~SteppingAction();
 
   virtual void UserSteppingAction(const G4Step *step) override;
   virtual void BeginOfEventAction(const G4Event *event) override;
   virtual void EndOfEventAction(const G4Event *event) override;
+  
+  void SetVerbosity(int level) { m_Verbosity = level; }
 
 private:
-  Vector<GeantEvent> *m_Output;   ///< destination for finished events
-  GeantEvent          m_Current;  ///< event being built
-  int                 m_LastEventID; ///< track event transitions
+  SimulationContext *m_Context;
+  GeantEvent         m_CurrentGeant;
+  MuonEvent          m_CurrentMuon;
+  int                m_MuonCrossCount = 0;
+  int                m_Verbosity = 0;
 };
 
 } // namespace Geant

src/HEP/Geant/testing/ActionInitialization.cpp

@@ -13,7 +13,7 @@ int main(int argc, char **argv) {
   // runManager->SetUserInitialization(new PhysicsList());
 
   // 3. INIZIALIZZAZIONE DELLE AZIONI (Il nostro generatore!)
-  runManager->SetUserInitialization(new uLib::Geant::ActionInitialization());
+  runManager->SetUserInitialization(new uLib::Geant::ActionInitialization(nullptr, nullptr));
 
   // ... Inizializzazione del kernel ( runManager->Initialize(); ), UI manager,
   // vis manager, ecc.

src/HEP/Geant/testing/CMakeLists.txt

@@ -4,6 +4,7 @@ set(TESTS
        EventTest
        GeantApp
        ActionInitialization
+       SkyPlaneEmitterTest
 )
 
 set(LIBRARIES

src/HEP/Geant/testing/SkyPlaneEmitterTest.cpp

@@ -0,0 +1,104 @@
+#include "Geant/Solid.h"
+#include "HEP/Geant/GeantEvent.h"
+#include "HEP/Geant/Scene.h"
+#include "HEP/Geant/EmitterPrimary.hh"
+#include "Math/ContainerBox.h"
+#include "Math/Dense.h"
+#include "Math/Units.h"
+#include "HEP/Detectors/DetectorChamber.h"
+
+#include <Geant4/G4SystemOfUnits.hh>
+
+#include <iostream>
+
+using namespace uLib;
+
+int main(int argc, char** argv) {
+
+    int nEvents = 10000;
+    if (argc > 1) {
+        nEvents = std::stoi(argv[1]);
+    }
+
+    // 1. Setup Geant4 Scene
+    Geant::Scene scene;
+    scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
+
+    ContainerBox iron_box;
+    iron_box.Scale(Vector3f(18_m, 10_cm, 18_m));
+    iron_box.SetPosition(Vector3f(-9_m, -5_cm, -9_m));
+    Geant::BoxSolid* iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
+    iron_cube->SetNistMaterial("G4_Fe");
+    iron_cube->Update();
+    scene.AddSolid(iron_cube);
+
+    // Top Detector Chamber (along Y axis)
+    DetectorChamber* top_chamber_box = new DetectorChamber();
+    top_chamber_box->Scale(Vector3f(20_m, 40_cm, 20_m));
+    top_chamber_box->Rotate(90_deg, Vector3f(1, 0, 0));
+    top_chamber_box->SetPosition(Vector3f(-10_m, 12_m, -10_m));
+    Geant::BoxSolid* top_chamber = new Geant::BoxSolid("TopChamber", top_chamber_box);
+    top_chamber->SetNistMaterial("G4_AIR");
+    top_chamber->Update();
+    scene.AddSolid(top_chamber);
+
+    // Bottom Detector Chamber (along Y axis)
+    DetectorChamber* bottom_chamber_box = new DetectorChamber();
+    bottom_chamber_box->Scale(Vector3f(20_m, 40_cm, 20_m));
+    bottom_chamber_box->Rotate(90_deg, Vector3f(1, 0, 0));
+    bottom_chamber_box->SetPosition(Vector3f(-10_m, -12_m, -10_m));
+    Geant::BoxSolid* bottom_chamber = new Geant::BoxSolid("BottomChamber", bottom_chamber_box);
+    bottom_chamber->SetNistMaterial("G4_AIR");
+    bottom_chamber->Update();
+    scene.AddSolid(bottom_chamber);
+
+    // Setup SkyPlaneEmitterPrimary
+    Geant::SkyPlaneEmitterPrimary* emitter = new Geant::SkyPlaneEmitterPrimary();
+    emitter->SetPosition(Vector3f(0, 14.9_m, 0));
+    emitter->Rotate(-90_deg, Vector3f(1, 0, 0));
+    emitter->SetSkySize(Vector2f(20_m, 20_m)); 
+    
+    scene.SetEmitter(emitter);
+    scene.SetVerbosity(1);
+    // scene.Initialize(); // Removed to avoid premature initialization
+
+
+    
+    std::cout << "Starting simulation of " << nEvents << " events..." << std::endl;
+    Vector<Geant::GeantEvent> results;
+    scene.RunSimulation(nEvents, results);
+
+    std::cout << "Simulation finished. Collected " << results.size() << " events." << std::endl;
+
+    // Sample output to verify data collection
+    if (!results.empty()) {
+        std::cout << "Summary: " << std::endl;
+        std::cout << "  Total events generated: " << results.size() << std::endl;
+        size_t total_steps = 0;
+        for (const auto& event : results) {
+            total_steps += event.Path().size();
+        }
+        std::cout << "  Total simulation steps: " << total_steps << std::endl;
+        std::cout << "  Average steps per event: " << static_cast<double>(total_steps) / results.size() << std::endl;
+    }
+
+    std::cout << "\nStarting Detector Simulation of " << nEvents << " events..." << std::endl;
+    Vector<MuonEvent> detectorResults;
+    scene.RunDetectorSimulation(nEvents, detectorResults);
+
+
+
+    std::cout << "Detector Simulation finished." << std::endl;
+    size_t hit_count = 0;
+    for (const auto& ev : detectorResults) {
+        if (!std::isnan(ev.LineIn().origin.x())) {
+            hit_count++;
+        }
+    }
+    std::cout << "  Muons crossing at least one detector: " << hit_count << std::endl;
+    if (nEvents > 0) {
+        std::cout << "  Efficiency: " << (100.0 * hit_count / nEvents) << "%" << std::endl;
+    }
+
+    return 0;
+}

src/Math/Assembly.cpp

@@ -0,0 +1,170 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#include "Math/Assembly.h"
+#include "Math/ContainerBox.h"
+#include "Math/Cylinder.h"
+
+#include <limits>
+#include <algorithm>
+#include <cstring>
+
+namespace uLib {
+
+Assembly::Assembly()
+    : ObjectsContext(),
+      TRS(),
+      m_BBoxMin(Vector3f::Zero()),
+      m_BBoxMax(Vector3f::Zero()),
+      m_ShowBoundingBox(false),
+      m_GroupSelection(true) {
+}
+
+Assembly::Assembly(const Assembly &copy)
+    : ObjectsContext(copy),
+      TRS(copy),
+      m_BBoxMin(copy.m_BBoxMin),
+      m_BBoxMax(copy.m_BBoxMax),
+      m_ShowBoundingBox(copy.m_ShowBoundingBox),
+      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 (auto *at = dynamic_cast<AffineTransform *>(obj)) {
+        at->SetParent(this);
+    }
+    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();
+}
+
+void Assembly::RemoveObject(Object *obj) {
+    if (auto *at = dynamic_cast<AffineTransform *>(obj)) {
+        if (at->GetParent() == this)
+            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();
+}
+
+void Assembly::ComputeBoundingBox() {
+    const auto &objects = this->GetObjects();
+    if (objects.empty()) {
+        m_BBoxMin = Vector3f::Zero();
+        m_BBoxMax = Vector3f::Zero();
+        return;
+    }
+
+    float inf = std::numeric_limits<float>::max();
+    m_BBoxMin = Vector3f(inf, inf, inf);
+    m_BBoxMax = Vector3f(-inf, -inf, -inf);
+
+    for (Object *obj : objects) {
+        if (auto *box = dynamic_cast<ContainerBox *>(obj)) {
+            // ContainerBox: wm is matrix from unit cube [0,1] to local space
+            // Since it is parented to 'this', GetMatrix() is sufficient.
+            Matrix4f m = box->GetMatrix();
+            for (int i = 0; i < 8; ++i) {
+                float x = (i & 1) ? 1.0f : 0.0f;
+                float y = (i & 2) ? 1.0f : 0.0f;
+                float z = (i & 4) ? 1.0f : 0.0f;
+                Vector4f corner = m * Vector4f(x, y, z, 1.0f);
+                for (int a = 0; a < 3; ++a) {
+                    m_BBoxMin(a) = std::min(m_BBoxMin(a), corner(a));
+                    m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
+                }
+            }
+        } else if (auto *cyl = dynamic_cast<Cylinder *>(obj)) {
+            // Cylinder: centered [-1, 1] radial, [-0.5, 0.5] height
+            Matrix4f m = cyl->GetMatrix();
+            for (int i = 0; i < 8; ++i) {
+                float x = (i & 1) ? 1.0f : -1.0f;
+                float y = (i & 2) ? 0.5f : -0.5f;
+                float z = (i & 4) ? 1.0f : -1.0f;
+                Vector4f corner = m * Vector4f(x, y, z, 1.0f);
+                for (int a = 0; a < 3; ++a) {
+                    m_BBoxMin(a) = std::min(m_BBoxMin(a), corner(a));
+                    m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
+                }
+            }
+        } else if (auto *subAsm = dynamic_cast<Assembly *>(obj)) {
+            // Recursive AABB for nested assemblies
+            subAsm->ComputeBoundingBox();
+            Vector3f subMin, subMax;
+            subAsm->GetBoundingBox(subMin, subMax);
+            Matrix4f m = subAsm->GetMatrix();
+            for (int i = 0; i < 8; ++i) {
+                float x = (i & 1) ? subMax(0) : subMin(0);
+                float y = (i & 2) ? subMax(1) : subMin(1);
+                float z = (i & 4) ? subMax(2) : subMin(2);
+                Vector4f corner = m * Vector4f(x, y, z, 1.0f);
+                for (int a = 0; a < 3; ++a) {
+                    m_BBoxMin(a) = std::min(m_BBoxMin(a), corner(a));
+                    m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
+                }
+            }
+        }
+    }
+}
+
+void Assembly::GetBoundingBox(Vector3f &bbMin, Vector3f &bbMax) const {
+    bbMin = m_BBoxMin;
+    bbMax = m_BBoxMax;
+}
+
+ContainerBox Assembly::GetBoundingBoxAsContainer() const {
+    ContainerBox bb;
+    Vector3f size = m_BBoxMax - m_BBoxMin;
+    bb.SetSize(size);
+    bb.SetPosition(m_BBoxMin);
+    return bb;
+}
+
+void Assembly::SetShowBoundingBox(bool show) {
+    m_ShowBoundingBox = show;
+    this->Updated();
+}
+
+bool Assembly::GetShowBoundingBox() const {
+    return m_ShowBoundingBox;
+}
+
+void Assembly::SetGroupSelection(bool group) {
+    m_GroupSelection = group;
+}
+
+bool Assembly::GetGroupSelection() const {
+    return m_GroupSelection;
+}
+
+} // namespace uLib

src/Math/Assembly.h

@@ -0,0 +1,122 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_ASSEMBLY_H
+#define U_ASSEMBLY_H
+
+#include "Core/ObjectsContext.h"
+#include "Math/ContainerBox.h"
+#include "Math/Transform.h"
+
+namespace uLib {
+
+/**
+ * @brief Assembly groups geometric objects (ContainerBox, Cylinder, etc.)
+ * under a common transformation.
+ *
+ * Assembly derives from ObjectsContext so objects can be added/removed
+ * dynamically. It also inherits AffineTransform to provide a group-level
+ * 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.
+ */
+class Assembly : public ObjectsContext, public TRS {
+public:
+    uLibTypeMacro(Assembly, ObjectsContext, TRS)
+    
+
+    Assembly();
+    Assembly(const Assembly &copy);
+    virtual ~Assembly();
+
+    template <class ArchiveT>
+    void serialize(ArchiveT & ar, const unsigned int version) {
+        ar & boost::serialization::make_nvp("TRS", boost::serialization::base_object<TRS>(*this));
+        ar & boost::serialization::make_hrp("GroupSelection", m_GroupSelection);
+    }
+
+    virtual void AddObject(Object* obj) override;
+    virtual void RemoveObject(Object* obj) override;
+
+    /**
+     * @brief Recomputes the axis-aligned bounding box enclosing all children.
+     * Stores the result internally.
+     */
+    void ComputeBoundingBox();
+
+    /**
+     * @brief Returns the bounding box as min/max corners (in assembly-local
+     * coordinates).
+     */
+    void GetBoundingBox(Vector3f &bbMin, Vector3f &bbMax) const;
+
+    /**
+     * @brief Returns the bounding box as a ContainerBox (positioned
+     * at bbMin, sized bbMax-bbMin, parented to this transform).
+     */
+    ContainerBox GetBoundingBoxAsContainer() const;
+
+    /**
+     * @brief Controls whether the bounding box wireframe should be shown
+     * in the viewer (used by the VTK puppet).
+     */
+    void SetShowBoundingBox(bool show);
+    bool GetShowBoundingBox() const;
+    
+    /**
+     * @brief Controls selection behavior.
+     * If true (default), clicking any child within the assembly will select 
+     * the assembly itself. If false, individual children can be picked.
+     */
+    void SetGroupSelection(bool group);
+    bool GetGroupSelection() const;
+
+signals:
+    virtual void Updated() override {
+        if (m_InUpdated) return; 
+        m_InUpdated = true;
+        
+        // Synchronize TRS part
+        this->TRS::Updated();
+        
+        this->ComputeBoundingBox();
+        m_InUpdated = false;
+    }
+
+private:
+    Vector3f m_BBoxMin;
+    Vector3f m_BBoxMax;
+    bool     m_ShowBoundingBox;
+    bool     m_GroupSelection;
+    bool     m_InUpdated = false;
+    std::map<Object*, Connection> m_ChildConnections;
+
+    ULIB_DECLARE_PROPERTIES(Assembly)
+};
+
+} // namespace uLib
+
+#endif // U_ASSEMBLY_H

src/Math/CMakeLists.txt

@@ -1,5 +1,7 @@
 
 set(HEADERS ContainerBox.h
+            Cylinder.h
+            Assembly.h
             Dense.h
             Geometry.h
             Transform.h
@@ -32,9 +34,11 @@ set(SOURCES VoxRaytracer.cpp
             VoxImage.cpp
             TriangleMesh.cpp
             QuadMesh.cpp
+            Assembly.cpp
             Dense.cpp
             Structured2DGrid.cpp
-            Structured4DGrid.cpp)
+            Structured4DGrid.cpp
+            MathRegistrations.cpp)
 
 set(LIBRARIES ${PACKAGE_LIBPREFIX}Core
               Eigen3::Eigen
@@ -69,4 +73,3 @@ if(BUILD_TESTING)
   include(uLibTargetMacros)
   add_subdirectory(testing)
 endif()
-

src/Math/ContainerBox.h

@@ -28,62 +28,91 @@
 
 #include "Geometry.h"
 #include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
 #include "Math/Dense.h"
 #include "Math/Transform.h"
 #include <utility>
 
+#include <iostream>
+
 namespace uLib {
 
 /**
  * @brief Represents an oriented bounding box (OBB) within a hierarchical
  * transformation system.
  *
- * ContainerBox inherits from AffineTransform, which defines its parent
+ * ContainerBox inherits from TRS, which defines its parent
  * coordinate system. It contains an internal local transformation (m_LocalT)
  * that defines the box's specific origin and size relative to its own
  * coordinate system.
  */
-class ContainerBox : public AffineTransform, public Object {
+class ContainerBox : public TRS {
 
-  typedef AffineTransform BaseClass;
+  uLibTypeMacro(ContainerBox, TRS)
+  ULIB_SERIALIZE_ACCESS
+  ULIB_DECLARE_PROPERTIES(ContainerBox)
 
 public:
+
   /**
    * @brief Default constructor.
    * Initializes the local transformation with this instance as its parent.
    */
   ContainerBox()
-      : m_LocalT(this) // BaseClass is Parent of m_LocalTransform
-  {}
+      : m_LocalT(this), // BaseClass is Parent of m_LocalTransform
+        Size(1.0f, 1.0f, 1.0f),
+        Origin(0.0f, 0.0f, 0.0f) {
+    this->Sync();
+  }
 
   /**
    * @brief Constructor with size.
    * @param size The size vector.
    */
-  ContainerBox(const Vector3f &size) : m_LocalT(this) { this->SetSize(size); }
+  ContainerBox(const Vector3f &size)
+      : m_LocalT(this),
+        Size(size),
+        Origin(0.0f, 0.0f, 0.0f) {
+    this->Sync();
+  }
 
   /**
    * @brief Copy constructor.
    * @param copy The ContainerBox instance to copy from.
    */
   ContainerBox(const ContainerBox &copy)
-      : m_LocalT(this), // BaseClass is Parent of m_LocalTransform
-        AffineTransform(copy) {
-    this->SetOrigin(copy.GetOrigin());
-    this->SetSize(copy.GetSize());
+      : m_LocalT(this), // Reset parent to the new object
+        TRS(copy),
+        Size(copy.Size),
+        Origin(copy.Origin) {
+    this->Sync();
+  }
+
+  // /**
+  //  * @brief Serialization template for property registration and persistence.
+  //  */
+  template <class ArchiveT>
+  void serialize(ArchiveT & ar, const unsigned int version) {
+    ar & HRP(Size);
+    ar & HRP(Origin);
+    ar & NVP("TRS", boost::serialization::base_object<TRS>(*this));
   }
 
   /**
    * @brief Sets the box origin relative to its coordinate system.
    * @param v The origin position vector.
    */
-  inline void SetOrigin(const Vector3f &v) { m_LocalT.SetPosition(v); }
+  void SetOrigin(const Vector3f &v) { 
+    Origin = v;
+    m_LocalT.SetPosition(v); 
+  }
 
   /**
    * @brief Gets the box origin relative to its coordinate system.
    * @return The origin position vector.
    */
-  inline Vector3f GetOrigin() const { return m_LocalT.GetPosition(); }
+  Vector3f GetOrigin() const { return m_LocalT.GetPosition(); }
 
   /**
    * @brief Sets the size of the box.
@@ -91,6 +120,7 @@ public:
    * @param v The size vector (width, height, depth).
    */
   void SetSize(const Vector3f &v) {
+    Size = v;
     Vector3f pos = this->GetOrigin();
     m_LocalT = AffineTransform(this); // regenerate local transform
     m_LocalT.Scale(v);
@@ -101,7 +131,7 @@ public:
    * @brief Gets the current size (scale) of the box.
    * @return The size vector.
    */
-  inline Vector3f GetSize() const { 
+  Vector3f GetSize() const { 
     Vector3f s = this->GetScale();
     Vector3f ls = m_LocalT.GetScale();
     return Vector3f(s(0) * ls(0), s(1) * ls(1), s(2) * ls(2));
@@ -112,7 +142,7 @@ public:
    * @param first Index of the first axis (0=X, 1=Y, 2=Z).
    * @param second Index of the second axis (0=X, 1=Y, 2=Z).
    */
-  inline void FlipLocalAxes(int first, int second) {
+  void FlipLocalAxes(int first, int second) {
     m_LocalT.FlipAxes(first, second);
   }
 
@@ -133,7 +163,7 @@ public:
    * @param v The local point (4D homogeneous vector).
    * @return The transformed point in world space.
    */
-  inline Vector4f GetWorldPoint(const Vector4f &v) const {
+  Vector4f GetWorldPoint(const Vector4f &v) const {
     return m_LocalT.GetWorldMatrix() * v;
   }
 
@@ -144,7 +174,7 @@ public:
    * @param z Z coordinate in local space.
    * @return The transformed point in world space.
    */
-  inline Vector4f GetWorldPoint(const float x, const float y, const float z) {
+  Vector4f GetWorldPoint(const float x, const float y, const float z) {
     return this->GetWorldPoint(Vector4f(x, y, z, 1));
   }
 
@@ -153,7 +183,7 @@ public:
    * @param v The world point (4D homogeneous vector).
    * @return The transformed point in box-local space.
    */
-  inline Vector4f GetLocalPoint(const Vector4f &v) const {
+  Vector4f GetLocalPoint(const Vector4f &v) const {
     return m_LocalT.GetWorldMatrix().inverse() * v;
   }
 
@@ -164,28 +194,48 @@ public:
    * @param z Z coordinate in world space.
    * @return The transformed point in box-local space.
    */
-  inline Vector4f GetLocalPoint(const float x, const float y, const float z) {
+  Vector4f GetLocalPoint(const float x, const float y, const float z) {
     return this->GetLocalPoint(Vector4f(x, y, z, 1));
   }
 
   /** Translate using transformation chain */
-  using BaseClass::Translate;
+  using AffineTransform::Translate;
 
   /** Rotate using transformation chain */
-  using BaseClass::Rotate;
+  using AffineTransform::Rotate;
 
   /** Scale using transformation chain */
-  using BaseClass::Scale;
+  using AffineTransform::Scale;
 
 signals:
 
-  // signal to emit when the box is updated //
-  virtual void Updated() override { ULIB_SIGNAL_EMIT(ContainerBox::Updated); }
+  /** Signal emitted when properties change */
+  virtual void Updated() override { 
+      // 1. Synchronize local box part (Size/Origin -> m_LocalT)
+      this->Sync();
+      
+      // 2. Synchronize TRS part (position/rotation/scaling -> m_T) and emit signal
+      this->TRS::Updated();
+      
+      // std::cout << "ContainerBox::Updated()" << std::endl;
+  }
 
 private:
+  /** Synchronizes internal transformation with properties */
+  void Sync() {
+      this->SetOrigin(Origin);
+      this->SetSize(Size);
+  }
+
+
+private:
+  Vector3f Size;
+  Vector3f Origin;
   AffineTransform m_LocalT;
+
 };
 
 } // namespace uLib
 
+
 #endif // CONTAINERBOX_H

src/Math/Cylinder.h

@@ -0,0 +1,202 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CYLINDER_H
+#define U_CYLINDER_H
+
+#include "Geometry.h"
+#include "Core/Object.h"
+#include "Math/Dense.h"
+#include "Math/Transform.h"
+
+namespace uLib {
+
+/**
+ * @brief Represents a cylindrical volume.
+ * 
+ * The cylinder orientation is defined by the Axis property (0=X, 1=Y, 2=Z).
+ * By default, it is aligned with the Y axis (Axis=1).
+ */
+class Cylinder : public TRS {
+
+    uLibTypeMacro(Cylinder, TRS)
+    ULIB_DECLARE_PROPERTIES(Cylinder)
+
+public:
+
+    /**
+     * @brief PROPERTIES
+     */
+    float Radius;
+    float Height;
+    int Axis;
+
+    
+
+    /**
+     * @brief Default constructor. Aligns with Y by default.
+     */
+    Cylinder() : m_LocalT(this), Radius(1.0), Height(1.0), Axis(1) {
+        this->Sync();
+    }
+
+    /**
+     * @brief Constructor with radius and height.
+     */
+    Cylinder(float radius, float height, int axis = 1)
+        : m_LocalT(this), Radius(radius), Height(height), Axis(axis) {
+        this->Sync();
+    }
+
+    /**
+     * @brief Copy constructor.
+     */
+    Cylinder(const Cylinder &copy)
+        : m_LocalT(this), TRS(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
+        this->Sync();
+    }
+
+    /**
+     * @brief Serialization template for property registration and persistence.
+     */
+    template <class ArchiveT>
+    void serialize(ArchiveT & ar, const unsigned int version) {
+        ar & HRP(Radius);
+        ar & HRP(Height);
+        ar & boost::serialization::make_hrp_enum("Axis", Axis, {"X", "Y", "Z"});
+        ar & NVP("TRS", boost::serialization::base_object<TRS>(*this));
+    }
+
+    /** Sets the radius of the cylinder */
+    inline void SetRadius(float r) { 
+        Radius = r; 
+        this->Sync(); 
+    }
+    
+    /** Gets the radius of the cylinder */
+    inline float GetRadius() const { return Radius; }
+
+    /** Sets the height of the cylinder */
+    inline void SetHeight(float h) { 
+        Height = h; 
+        this->Sync(); 
+    }
+    
+    /** Gets the height of the cylinder */
+    inline float GetHeight() const { return Height; }
+
+    /** Sets the main axis (0=X, 1=Y, 2=Z) */
+    inline void SetAxis(int axis) {
+        Axis = axis;
+        this->Sync();
+    }
+
+    /** Gets the main axis */
+    inline int GetAxis() const { return Axis; }
+
+    /**
+     * @brief Returns the world transformation matrix.
+     */
+    Matrix4f GetWorldMatrix() const { return m_LocalT.GetWorldMatrix(); }
+
+    /**
+     * @brief Returns the local transformation matrix.
+     */
+    Matrix4f GetLocalMatrix() const { return m_LocalT.GetMatrix(); }
+
+    /**
+     * @brief Transforms local cylindrical coordinates to world space.
+     * @param r Local radius.
+     * @param theta Local angle in radians (around main axis).
+     * @param h Local height along main axis.
+     */
+    inline Vector4f GetWorldPoint(float r, float theta, float h) const {
+        Vector3f p;
+        if (Axis == 0) p = Vector3f(h, r * std::cos(theta), r * std::sin(theta));
+        else if (Axis == 1) p = Vector3f(r * std::cos(theta), h, r * std::sin(theta));
+        else p = Vector3f(r * std::cos(theta), r * std::sin(theta), h);
+        
+        return AffineTransform::GetWorldMatrix() * Vector4f(p.x(), p.y(), p.z(), 1.0f);
+    }
+
+    /**
+     * @brief Transforms a world point to cylindrical local space.
+     * @return Vector3f(r, theta, h)
+     */
+    inline Vector3f GetCylindricalLocal(const Vector4f &world_v) const {
+        Vector4f local_v = AffineTransform::GetWorldMatrix().inverse() * world_v;
+        float r, theta, h;
+        if (Axis == 0) {
+            h = local_v.x();
+            r = std::sqrt(local_v.y() * local_v.y() + local_v.z() * local_v.z());
+            theta = std::atan2(local_v.z(), local_v.y());
+        } else if (Axis == 1) {
+            h = local_v.y();
+            r = std::sqrt(local_v.x() * local_v.x() + local_v.z() * local_v.z());
+            theta = std::atan2(local_v.z(), local_v.x());
+        } else {
+            h = local_v.z();
+            r = std::sqrt(local_v.x() * local_v.x() + local_v.y() * local_v.y());
+            theta = std::atan2(local_v.y(), local_v.x());
+        }
+        return Vector3f(r, theta, h);
+    }
+
+    /** Translate using transformation chain */
+    using AffineTransform::Translate;
+
+    /** Rotate using transformation chain */
+    using AffineTransform::Rotate;
+
+    /** Scale using transformation chain */
+    using AffineTransform::Scale;
+
+signals:
+    /** Signal emitted when properties change */
+    virtual void Updated() override { 
+        // 1. Synchronize local cylinder part (Radius/Height/Axis -> m_LocalT)
+        this->Sync();
+        
+        // 2. Synchronize TRS part (position/rotation/scaling -> m_T) and emit signal
+        this->TRS::Updated();
+    }
+
+private:
+  /** Synchronizes internal transformation with properties */
+  void Sync() {
+      m_LocalT = AffineTransform(this);
+      if (Axis == 0) m_LocalT.Scale(Vector3f(Height, Radius, Radius));
+      else if (Axis == 1) m_LocalT.Scale(Vector3f(Radius, Height, Radius));
+      else m_LocalT.Scale(Vector3f(Radius, Radius, Height));
+  }
+
+
+private:
+    AffineTransform m_LocalT;
+};
+
+} // namespace uLib
+
+#endif // U_CYLINDER_H

src/Math/Dense.h

@@ -51,6 +51,8 @@
 #include <stdlib.h>
 
 #include <Eigen/Dense>
+#include "Core/Types.h"
+#include "Core/Property.h"
 
 //// BOOST SERIALIZATION ///////////////////////////////////////////////////////
 
@@ -107,7 +109,6 @@ std::ostream &operator<<(std::ostream &os,
 namespace uLib {
 
 typedef id_t Id_t;
-
 typedef int Scalari;
 typedef unsigned int Scalarui;
 typedef long Scalarl;
@@ -249,15 +250,53 @@ 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) {
+   stream << "HError3f(" << "ept[" << err.position_error.transpose()
+          << "] , edr[" << err.direction_error.transpose() << "]) ";
+   return stream;
+ }
+ 
+typedef Property<Scalari>   ScalariProperty;
+typedef Property<Scalarui>  ScalaruiProperty;
+typedef Property<Scalarl>   ScalarlProperty;
+typedef Property<Scalarul>  ScalarulProperty;
+typedef Property<Scalarf>   ScalarfProperty;
+typedef Property<Scalard>   ScalardProperty;
 
-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<Vector1i>  Vector1iProperty;
+typedef Property<Vector1f>  Vector1fProperty;
+typedef Property<Vector1d>  Vector1dProperty;
 
-} // namespace uLib
+typedef Property<Vector2i> Vector2iProperty;
+typedef Property<Vector3i> Vector3iProperty;
+typedef Property<Vector4i> Vector4iProperty;
+
+typedef Property<Vector2f> Vector2fProperty;
+typedef Property<Vector3f> Vector3fProperty;
+typedef Property<Vector4f> Vector4fProperty;
+
+typedef Property<Vector2d> Vector2dProperty;
+typedef Property<Vector3d> Vector3dProperty;
+typedef Property<Vector4d> Vector4dProperty;
+
+typedef Property<Matrix2i> Matrix2iProperty;
+typedef Property<Matrix3i> Matrix3iProperty;
+typedef Property<Matrix4i> Matrix4iProperty;
+
+typedef Property<Matrix2f> Matrix2fProperty;
+typedef Property<Matrix3f> Matrix3fProperty;
+typedef Property<Matrix4f> Matrix4fProperty;
+
+typedef Property<Matrix2d> Matrix2dProperty;
+typedef Property<Matrix3d> Matrix3dProperty;
+typedef Property<Matrix4d> Matrix4dProperty;
+
+typedef Property<HVector3f> HVector3fProperty;
+typedef Property<HPoint3f>  HPoint3fProperty;
+
+ } // namespace uLib
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////