algorithm chain for ram-vram

.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: ["*"]
 

.gitignore

@@ -1,7 +1,6 @@
 CMakeFiles/
-build*/
+build/
 .cache/
-CMakeUserPresets.json
 build_warnings*.log
 final_build.log
 cmake_configure.log
@@ -14,7 +13,3 @@ 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
-.claude/settings.json

.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,7 +19,8 @@
     "clangd.semanticHighlighting.enable": true,
     "clangd.arguments": [
         "--compile-commands-dir=build",
-        "--query-driver=/home/share/micromamba/envs/mutom/bin/*",
+        "--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",
         "--all-scopes-completion",
         "--completion-style=detailed",
         "--header-insertion=never",

CLAUDE.md

@@ -12,7 +12,7 @@ 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 — uses Ninja + ccache)
+# Configure (from repo root, using Conan preset)
 cmake --preset conan-release
 
 # Build everything
@@ -40,18 +40,6 @@ conan install . --output-folder=build --build=missing
 cmake --preset conan-release
 ```
 
-### Build acceleration (already configured)
-- **Ninja** generator — used automatically via the conan default profile (`~/.conan2/profiles/default`)
-- **ccache** — enabled via `CMAKE_CXX_COMPILER_LAUNCHER=ccache`; cached rebuilds are nearly instant (~0.3s vs ~25s cold)
-- **Clang 22 + lld** profile available (`~/.conan2/profiles/fast`) but blocked by template overload ambiguities in `src/Core/Archives.h` that need fixing for full compatibility
-
-To reconfigure with the fast profile once Archives.h is fixed:
-```bash
-conan install . --output-folder=build --build=missing --profile=fast
-cmake -B build -G Ninja -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
-cmake --build build -j$(nproc)
-```
-
 ## Architecture
 
 **uLib** is a C++ framework for Cosmic Muon Tomography (CMT), structured as layered shared libraries:

CMakeLists.txt

@@ -38,7 +38,7 @@ endif()
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 7)
+set(PROJECT_VERSION_MINOR 6)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -169,26 +169,6 @@ if(Geant4_FOUND)
     add_compile_definitions(HAVE_GEANT4)
     set(HAVE_GEANT4 1)
 
-    # Workaround: Geant4's G4EXPATShim creates EXPAT::EXPAT (uppercase) with
-    # IMPORTED_LOCATION "${EXPAT_LIBRARY}", but EXPAT_LIBRARY is empty when using
-    # conda's config-mode expat package (which installs as expat::expat lowercase).
-    # Resolve the actual library path from expat::expat or via find_library.
-    if(TARGET EXPAT::EXPAT)
-        get_target_property(_expat_loc EXPAT::EXPAT IMPORTED_LOCATION)
-        if(NOT _expat_loc OR _expat_loc MATCHES "NOTFOUND|^$")
-            if(TARGET expat::expat)
-                get_target_property(_expat_loc expat::expat IMPORTED_LOCATION_NOCONFIG)
-            endif()
-            if(NOT _expat_loc OR _expat_loc MATCHES "NOTFOUND|^$")
-                find_library(_expat_loc NAMES expat)
-            endif()
-            if(_expat_loc)
-                set_target_properties(EXPAT::EXPAT PROPERTIES IMPORTED_LOCATION "${_expat_loc}")
-            endif()
-        endif()
-        unset(_expat_loc)
-    endif()
-
     # Sanitize Geant4 targets to remove Qt5 dependencies that conflict with VTK/Qt6
     if(TARGET Geant4::G4interfaces)
         set_target_properties(Geant4::G4interfaces PROPERTIES 

CMakePresets.json

@@ -11,28 +11,6 @@
                 "CMAKE_BUILD_TYPE": "Debug",
                 "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
             }
-        },
-        {
-            "name": "fast",
-            "displayName": "Fast build: Ninja + clang + ccache",
-            "description": "Uses Ninja generator, clang/lld compiler, and ccache",
-            "generator": "Ninja",
-            "binaryDir": "${sourceDir}/build",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "CMAKE_C_COMPILER": "clang",
-                "CMAKE_CXX_COMPILER": "clang++",
-                "CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
-                "CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
-                "CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
-                "CMAKE_C_COMPILER_LAUNCHER": "ccache"
-            }
-        },
-        {
-            "name": "mutom",
-            "description": "",
-            "displayName": "",
-            "inherits": []
         }
     ]
 }

CMakeUserPresets.json

@@ -0,0 +1,9 @@
+{
+    "version": 4,
+    "vendor": {
+        "conan": {}
+    },
+    "include": [
+        "build/CMakePresets.json"
+    ]
+}

README.md

@@ -41,11 +41,7 @@ conda activate mutom
 
 ### Configure and Build
 
-#### Standard build (GCC + Ninja + ccache)
+1. **Configure Conan profile (if you haven't yet on your machine):**
-
-The default conan profile uses **Ninja** as the generator and **ccache** for compiler caching, dramatically speeding up incremental rebuilds.
-
-1. **Configure Conan profile (first time only):**
 ```bash
 conan profile detect
 ```
@@ -55,39 +51,17 @@ conan profile detect
 conan install . --output-folder=build --build=missing
 ```
 
-3. **Configure with CMake:**
+3. **Configure the project with CMake:**
 ```bash
 cmake --preset conan-release
 ```
+*(Alternatively: `cd build && cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release`)*
 
-4. **Build:**
+4. **Build the project:**
 ```bash
-cmake --build build -j$(nproc)
+cmake --build build -j10
 ```
 
-#### LLVM/Clang build (clang + lld + ccache — fastest)
-
-A `fast` conan profile is provided that uses **clang**, **lld** (LLVM linker), and **ccache**. Install them into your environment first:
-
-```bash
-micromamba install -n mutom -y clang clangxx lld -c conda-forge
-```
-
-Then build using the `fast` profile:
-
-```bash
-conan install . --output-folder=build --build=missing --profile=fast
-cmake -B build -G Ninja \
-      -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake \
-      -DCMAKE_BUILD_TYPE=Release
-cmake --build build -j$(nproc)
-```
-
-The `fast` profile is defined at `~/.conan2/profiles/fast` and sets:
-- `CMAKE_C_COMPILER=clang` / `CMAKE_CXX_COMPILER=clang++`
-- `CMAKE_EXE_LINKER_FLAGS=-fuse-ld=lld`
-- `CMAKE_CXX_COMPILER_LAUNCHER=ccache`
-
 ### Make python package
 
 ```bash

app/gcompose/src/ContextModel.cpp

@@ -4,11 +4,6 @@
 #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) {}
@@ -16,16 +11,12 @@ ContextModel::ContextModel(QObject* parent)
 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);
@@ -34,6 +25,7 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
             refresh();
         });
         uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectRemoved, [this, refresh](uLib::Object* obj) {
+            // Disconnect would be good here but not strictly required if refresh handles it
             refresh();
         });
 
@@ -43,7 +35,6 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
         }
     }
     endResetModel();
-    m_isReseting = false;
 }
 
 QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent) const {
@@ -57,8 +48,8 @@ QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent)
         }
     } else {
         uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
-        uLib::ObjectsContext* parentCtx = parentObj->GetChildren();
+        uLib::ObjectsContext* parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
-        if (parentCtx && row < (int)parentCtx->GetCount()) {
+        if (parentCtx && row < parentCtx->GetCount()) {
             return createIndex(row, column, parentCtx->GetObject(row));
         }
     }
@@ -74,37 +65,36 @@ QModelIndex ContextModel::parent(const QModelIndex& child) const {
     
     // 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 = 
+    std::function<uLib::ObjectsContext*(uLib::ObjectsContext*, uLib::Object*)> findParent = 
-        [&findParent](uLib::Object* current, uLib::Object* target) -> uLib::Object* {
+        [&findParent](uLib::ObjectsContext* ctx, uLib::Object* target) -> uLib::ObjectsContext* {
-        uLib::ObjectsContext* ctx = current->GetChildren();
-        if (ctx) {
         for (const auto& obj : ctx->GetObjects()) {
-                if (obj == target) return current;
+            if (obj == target) return ctx;
-                if (auto p = findParent(obj, target)) return p;
+            if (auto subCtx = dynamic_cast<uLib::ObjectsContext*>(obj)) {
+                if (auto p = findParent(subCtx, target)) return p;
             }
         }
         return nullptr;
     };
 
-    uLib::Object* parentObj = findParent(m_rootContext, childObj);
+    uLib::ObjectsContext* parentCtx = findParent(m_rootContext, childObj);
-    if (!parentObj || parentObj == m_rootContext) {
+    if (!parentCtx || parentCtx == m_rootContext) {
         return QModelIndex(); // Root items have invalid parent index
     }
 
-    // Now need to find the row of parentObj in its own parent Context.
+    // Now need to find the row of parentCtx in its own parent Context.
-    uLib::Object* grandParentObj = findParent(m_rootContext, parentObj);
+    uLib::ObjectsContext* grandParentCtx = findParent(m_rootContext, parentCtx);
-    uLib::ObjectsContext* grandParentCtx = grandParentObj ? grandParentObj->GetChildren() : m_rootContext;
+    if (!grandParentCtx) grandParentCtx = m_rootContext;
 
     int row = -1;
     for (size_t i = 0; i < grandParentCtx->GetCount(); ++i) {
-        if (grandParentCtx->GetObject(i) == parentObj) {
+        if (grandParentCtx->GetObject(i) == parentCtx) {
             row = (int)i;
             break;
         }
     }
 
     if (row != -1) {
-        return createIndex(row, 0, parentObj);
+        return createIndex(row, 0, parentCtx);
     }
     return QModelIndex();
 }
@@ -117,8 +107,8 @@ int ContextModel::rowCount(const QModelIndex& parent) const {
     }
 
     uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
-    if (auto parentCtx = parentObj->GetChildren()) {
+    if (auto parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj)) {
-        return (int)parentCtx->GetCount();
+        return parentCtx->GetCount();
     }
     return 0; // leaf node
 }
@@ -171,98 +161,8 @@ QVariant ContextModel::headerData(int section, Qt::Orientation orientation, int
 }
 
 Qt::ItemFlags ContextModel::flags(const QModelIndex& index) const {
-    if (!index.isValid()) return m_rootContext ? Qt::ItemIsDropEnabled : Qt::NoItemFlags;
+    if (!index.isValid()) return Qt::NoItemFlags;
-    
+    return Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
-    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) {

app/gcompose/src/ContextModel.h

@@ -21,15 +21,8 @@ public:
     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

@@ -38,10 +38,6 @@ ContextPanel::ContextPanel(QWidget* parent)
     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);

app/gcompose/src/PropertyWidgets.cpp

@@ -7,10 +7,6 @@
 #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 {
@@ -23,7 +19,7 @@ PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent)
     
     std::string unit = prop->GetUnits();
     QString labelText = QString::fromStdString(prop->GetName());
-    if (!unit.empty() && unit != "color") {
+    if (!unit.empty()) {
         auto dim = Settings::Instance().IdentifyDimension(unit);
         std::string pref = Settings::Instance().GetPreferredUnit(dim);
         if (!pref.empty()) {
@@ -36,8 +32,6 @@ PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent)
     m_Label = new QLabel(labelText, this);
     m_Label->setMinimumWidth(120);
     m_Layout->addWidget(m_Label);
-
-    this->setEnabled(!prop->IsReadOnly());
 }
 PropertyWidgetBase::~PropertyWidgetBase() {
     m_Connection.disconnect();
@@ -51,7 +45,7 @@ double parseWithUnits(const QString& text, double* factorOut, QString* suffixOut
 
     double num = match.captured(1).toDouble();
     QString unit = match.captured(3);
-    double factor = factorOut ? *factorOut : 1.0;
+    double factor = 1.0;
 
     if (!unit.isEmpty()) {
         QString u = unit.startsWith('_') ? unit.mid(1) : unit;
@@ -107,6 +101,10 @@ void UnitLineEdit::onEditingFinished() {
     double factor = m_Factor;
     QString suffix = m_Suffix;
     double parsedVal = parseWithUnits(text(), &factor, &suffix);
+    if (!suffix.isEmpty()) {
+        m_Suffix = suffix;
+        m_Factor = factor;
+    }
     if (m_IsInteger) {
         parsedVal = std::round(parsedVal);
     }
@@ -152,7 +150,7 @@ DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* pare
     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_Connection = uLib::Object::connect(m_Prop, &Property<double>::PropertyChanged, [this](){
         m_Edit->setValue(m_Prop->Get());
     });
 }
@@ -170,7 +168,7 @@ FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
     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_Connection = uLib::Object::connect(m_Prop, &Property<float>::PropertyChanged, [this](){
         m_Edit->setValue((double)m_Prop->Get());
     });
 }
@@ -189,7 +187,7 @@ IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
     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_Connection = uLib::Object::connect(m_Prop, &Property<int>::PropertyChanged, [this](){
         m_Edit->setValue((double)m_Prop->Get());
     });
 }
@@ -200,7 +198,7 @@ BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
     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](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::PropertyChanged, [this](){
         if (m_CheckBox->isChecked() != m_Prop->Get()) {
             QSignalBlocker blocker(m_CheckBox);
             m_CheckBox->setChecked(m_Prop->Get());
@@ -209,76 +207,6 @@ BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
 }
 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);
@@ -288,7 +216,7 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
         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](){
+    m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::PropertyChanged, [this](){
         if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
             QSignalBlocker blocker(m_LineEdit);
             m_LineEdit->setText(QString::fromStdString(m_Prop->Get()));
@@ -336,7 +264,7 @@ public:
                 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](){
+            m_Connection = uLib::Object::connect(p, &Property<int>::PropertyChanged, [this, p](){
                 if (m_Combo->currentIndex() != p->Get()) {
                     QSignalBlocker blocker(m_Combo);
                     m_Combo->setCurrentIndex(p->Get());
@@ -434,18 +362,6 @@ void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
             // 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());

app/gcompose/src/PropertyWidgets.h

@@ -2,8 +2,6 @@
 #define PROPERTY_WIDGETS_H
 
 #include <QWidget>
-class QPushButton;
-class QSlider;
 #include <QLabel>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
@@ -115,7 +113,6 @@ public:
             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){
@@ -125,7 +122,7 @@ public:
             });
         }
         updateEdits();
-        m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::Updated, [this](){
+        m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::PropertyChanged, [this](){
             updateEdits();
         });
     }
@@ -144,20 +141,6 @@ private:
     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:
@@ -168,19 +151,6 @@ private:
     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:

docs/algorithms/algoritm.md

@@ -0,0 +1,338 @@
+# Algorithm Infrastructure
+
+## Overview
+
+An algorithm in the uLib infrastructure is a class for containing a functional that can be dynamically loaded into memory as a plug-in.
+It derives from the base `Object` class (`Core/Object.h`) and therefore can contain properties that define the serialization of operating parameters or the implementation of widgets for interactive parameter manipulation.
+
+The algorithm class is designed to be inserted into an `AlgorithmTask`, a class for managing the execution of scheduled operations. A task contains `Run` and `Stop` methods to start and stop execution. A task can be configured to work in two modes:
+
+- **Cyclic mode**: the algorithm is executed periodically with a configurable cycle time.
+- **Asynchronous mode**: the task waits for a trigger before each execution. Triggers can come from the uLib signal-slot system (`Object::connect`) or from a condition variable as defined in the monitor pattern (`Core/Monitor.h`).
+
+The algorithm is defined as a template class on two types `T_enc` and `T_dec`. The encoder is a type for data input or another algorithm that is chained with this one and outputs data in a compatible format. The decoder is the type of data output or a downstream algorithm compatible with it.
+
+## Class Hierarchy
+
+```
+Object (Core/Object.h)
+  |
+  +-- Algorithm<T_enc, T_dec>        (Core/Algorithm.h)
+  |     |
+  |     +-- VoxImageFilter<VoxelT, CrtpImplT>  (Math/VoxImageFilter.h)
+  |           |
+  |           +-- VoxFilterAlgorithmLinear       (Math/VoxImageFilterLinear.hpp)
+  |           +-- VoxFilterAlgorithmMedian       (Math/VoxImageFilterMedian.hpp)
+  |           +-- VoxFilterAlgorithmAbtrim       (Math/VoxImageFilterABTrim.hpp)
+  |           +-- VoxFilterAlgorithmSPR          (Math/VoxImageFilterABTrim.hpp)
+  |           +-- VoxFilterAlgorithmThreshold    (Math/VoxImageFilterThreshold.hpp)
+  |           +-- VoxFilterAlgorithmBilateral    (Math/VoxImageFilterBilateral.hpp)
+  |           +-- VoxFilterAlgorithmBilateralTrim(Math/VoxImageFilterBilateral.hpp)
+  |           +-- VoxFilterAlgorithm2ndStat      (Math/VoxImageFilter2ndStat.hpp)
+  |           +-- VoxFilterAlgorithmCustom        (Math/VoxImageFilterCustom.hpp)
+  |
+  +-- Thread (Core/Threads.h)
+        |
+        +-- AlgorithmTask<T_enc, T_dec>  (Core/Algorithm.h)
+```
+
+## Algorithm (`Core/Algorithm.h`)
+
+### Template Parameters
+
+```cpp
+template <typename T_enc, typename T_dec>
+class Algorithm : public Object;
+```
+
+- **`T_enc`** (Encoder): the input data type. Can be a raw data type or a pointer to a data structure. When chaining algorithms, the upstream algorithm's `T_dec` must be compatible with this algorithm's `T_enc`.
+- **`T_dec`** (Decoder): the output data type. Produced by `Process()` and consumed by the next algorithm in the chain.
+
+### Core Interface
+
+| Method | Description |
+|--------|-------------|
+| `virtual T_dec Process(const T_enc& input) = 0` | Pure virtual. Implement the algorithm logic here. |
+| `T_dec operator()(const T_enc& input)` | Calls `Process()`. Enables functional syntax: `result = alg(data)`. |
+
+### Algorithm Chaining
+
+Algorithms can be linked in processing pipelines via encoder/decoder pointers:
+
+```cpp
+Algorithm* upstream;    // SetEncoder() / GetEncoder()
+Algorithm* downstream;  // SetDecoder() / GetDecoder()
+```
+
+This allows building chains like:
+
+```
+[RawData] --> AlgorithmA --> AlgorithmB --> [Result]
+               encoder         decoder
+```
+
+### Signals
+
+| Signal | Emitted when |
+|--------|-------------|
+| `Started()` | The algorithm begins processing (caller responsibility). |
+| `Finished()` | The algorithm completes processing (caller responsibility). |
+
+### Device Preference (CUDA)
+
+Algorithms report their preferred execution device via `GetPreferredDevice()`:
+
+| Method | Description |
+|--------|-------------|
+| `virtual MemoryDevice GetPreferredDevice() const` | Returns `RAM` or `VRAM`. Subclasses override. |
+| `void SetPreferredDevice(MemoryDevice dev)` | Manually set the device preference. |
+| `bool IsGPU() const` | Shorthand for `GetPreferredDevice() == VRAM`. |
+
+GPU-based algorithms are responsible for calling `cudaDeviceSynchronize()` inside their `Process()` implementation before returning, so that results are available to the caller or downstream algorithm.
+
+### Example: Defining a Custom Algorithm
+
+```cpp
+class MyFilter : public Algorithm<VoxImage<Voxel>*, VoxImage<Voxel>*> {
+public:
+    const char* GetClassName() const override { return "MyFilter"; }
+
+    VoxImage<Voxel>* Process(VoxImage<Voxel>* const& image) override {
+        // ... filter the image in-place ...
+        return image;
+    }
+};
+```
+
+## AlgorithmTask (`Core/Algorithm.h`)
+
+`AlgorithmTask` manages the execution of an `Algorithm` within a scheduled, threaded context. It inherits from `Thread` (`Core/Threads.h`) and uses `Mutex` (`Core/Monitor.h`) for synchronization.
+
+### Template Parameters
+
+```cpp
+template <typename T_enc, typename T_dec>
+class AlgorithmTask : public Thread;
+```
+
+Must match the `Algorithm<T_enc, T_dec>` it manages.
+
+### Configuration
+
+| Method | Description |
+|--------|-------------|
+| `void SetAlgorithm(AlgorithmType* alg)` | Set the algorithm to execute. |
+| `void SetMode(Mode mode)` | `Cyclic` or `Async`. |
+| `void SetCycleTime(int ms)` | Period for cyclic mode (milliseconds). |
+
+### Execution Modes
+
+#### Cyclic Mode
+
+The algorithm's `Process()` is called periodically. The cycle waits on a `condition_variable_any` with timeout, so `Stop()` can interrupt immediately without waiting for the full cycle.
+
+```cpp
+AlgorithmTask<int, int> task;
+task.SetAlgorithm(&myAlgorithm);
+task.SetMode(AlgorithmTask<int, int>::Cyclic);
+task.SetCycleTime(100);  // every 100ms
+task.Run(inputData);
+// ... later ...
+task.Stop();
+```
+
+#### Asynchronous Mode
+
+The task thread blocks on a condition variable until `Notify()` is called. Each notification triggers exactly one `Process()` invocation.
+
+```cpp
+task.SetMode(AlgorithmTask<int, int>::Async);
+task.Run(inputData);
+
+// Trigger manually:
+task.Notify();
+
+// Or connect to a signal:
+task.ConnectTrigger(sender, &SenderClass::DataReady);
+// Now each emission of DataReady() triggers one Process() call.
+```
+
+### Lifecycle
+
+| Method | Description |
+|--------|-------------|
+| `void Run(const T_enc& input)` | Starts the background thread with the given input. |
+| `void Stop()` | Requests stop and joins the thread. |
+| `bool IsRunning()` | Inherited from `Thread`. |
+
+### Signals
+
+| Signal | Emitted when |
+|--------|-------------|
+| `Stopped()` | The task thread has completed (after last `Process()` and before thread exit). |
+
+### Signal-Slot Triggering
+
+`ConnectTrigger()` connects any uLib `Object` signal to the task's `Notify()` method:
+
+```cpp
+task.ConnectTrigger(detector, &Detector::EventReady);
+```
+
+This uses the uLib signal system (`Core/Signal.h`), not Qt signals. The connection is type-safe and works with the `Object::connect` infrastructure.
+
+## VoxImageFilter (`Math/VoxImageFilter.h`)
+
+`VoxImageFilter` specializes `Algorithm` for kernel-based volumetric image filtering. It uses CRTP (Curiously Recurring Template Pattern) so that concrete filters provide their `Evaluate()` method without virtual dispatch overhead in the inner loop.
+
+### Template Parameters
+
+```cpp
+template <typename VoxelT, typename CrtpImplT>
+class VoxImageFilter : public Abstract::VoxImageFilter,
+                       public Algorithm<VoxImage<VoxelT>*, VoxImage<VoxelT>*>;
+```
+
+- **`VoxelT`**: the voxel data type (must satisfy `Interface::Voxel` — requires `.Value` and `.Count` fields).
+- **`CrtpImplT`**: the concrete filter subclass. Must implement:
+  ```cpp
+  float Evaluate(const VoxImage<VoxelT>& buffer, int index);
+  ```
+
+### How It Works
+
+1. `Process(image)` creates a read-only buffer copy of the input image.
+2. For each voxel in parallel (OpenMP), it calls `CrtpImplT::Evaluate(buffer, index)`.
+3. `Evaluate()` reads from the buffer using the kernel offsets and writes the result.
+4. The filtered image is returned (in-place modification).
+
+```
+Process(image)
+  |
+  +-- buffer = copy of image (read-only snapshot)
+  |
+  +-- #pragma omp parallel for
+  |     for each voxel i:
+  |       image[i].Value = CrtpImplT::Evaluate(buffer, i)
+  |
+  +-- return image
+```
+
+### Kernel System
+
+The `Kernel<VoxelT>` class stores convolution weights and precomputed index offsets:
+
+| Method | Description |
+|--------|-------------|
+| `SetKernelNumericXZY(values)` | Set kernel weights from a flat vector (XZY order). |
+| `SetKernelSpherical(shape)` | Set weights via a radial function `f(distance^2)`. |
+| `SetKernelWeightFunction(shape)` | Set weights via a 3D position function `f(Vector3f)`. |
+
+### CUDA Support
+
+Concrete filters can override `Process()` with a CUDA implementation:
+
+```cpp
+#if defined(USE_CUDA) && defined(__CUDACC__)
+VoxImage<VoxelT>* Process(VoxImage<VoxelT>* const& image) override {
+    if (this->GetPreferredDevice() == MemoryDevice::VRAM) {
+        // Launch CUDA kernel, synchronize, return
+    } else {
+        return BaseClass::Process(image);  // CPU fallback
+    }
+}
+#endif
+```
+
+The base class `GetPreferredDevice()` automatically returns `VRAM` when the image or kernel data resides on the GPU, enabling transparent device dispatch.
+
+Filters with CUDA implementations: `VoxFilterAlgorithmLinear`, `VoxFilterAlgorithmAbtrim`, `VoxFilterAlgorithmSPR`.
+
+### Concrete Filters
+
+| Filter | File | Description |
+|--------|------|-------------|
+| `VoxFilterAlgorithmLinear` | `VoxImageFilterLinear.hpp` | Weighted linear convolution (FIR filter). CUDA-enabled. |
+| `VoxFilterAlgorithmMedian` | `VoxImageFilterMedian.hpp` | Median filter with kernel-weighted sorting. |
+| `VoxFilterAlgorithmAbtrim` | `VoxImageFilterABTrim.hpp` | Alpha-beta trimmed mean filter. CUDA-enabled. |
+| `VoxFilterAlgorithmSPR` | `VoxImageFilterABTrim.hpp` | Robespierre filter: trimmed mean applied only to outlier voxels. CUDA-enabled. |
+| `VoxFilterAlgorithmThreshold` | `VoxImageFilterThreshold.hpp` | Binary threshold filter. |
+| `VoxFilterAlgorithmBilateral` | `VoxImageFilterBilateral.hpp` | Edge-preserving bilateral filter (intensity-weighted Gaussian). |
+| `VoxFilterAlgorithmBilateralTrim` | `VoxImageFilterBilateral.hpp` | Bilateral filter with alpha-beta trimming. |
+| `VoxFilterAlgorithm2ndStat` | `VoxImageFilter2ndStat.hpp` | Local variance (second-order statistic). |
+| `VoxFilterAlgorithmCustom` | `VoxImageFilterCustom.hpp` | User-supplied evaluation function via function pointer. |
+
+### Example: Using a Filter with AlgorithmTask
+
+```cpp
+// Create filter and configure kernel
+VoxFilterAlgorithmLinear<Voxel> filter(Vector3i(3, 3, 3));
+std::vector<float> weights(27, 1.0f);  // uniform 3x3x3
+filter.SetKernelNumericXZY(weights);
+
+// Direct use
+filter.SetImage(&image);
+filter.Run();
+
+// Or via Algorithm interface
+VoxImage<Voxel>* result = filter.Process(&image);
+
+// Or scheduled in a task
+AlgorithmTask<VoxImage<Voxel>*, VoxImage<Voxel>*> task;
+task.SetAlgorithm(&filter);
+task.SetMode(AlgorithmTask<VoxImage<Voxel>*, VoxImage<Voxel>*>::Cyclic);
+task.SetCycleTime(500);
+task.Run(&image);
+```
+
+## Structural Benefits
+
+### 1. Uniform Processing Interface
+
+Every algorithm — from a simple threshold to a GPU-accelerated convolution — exposes the same `Process(input) -> output` interface. Client code does not need to know the concrete type:
+
+```cpp
+Algorithm<VoxImage<Voxel>*, VoxImage<Voxel>*>* alg = &anyFilter;
+alg->Process(&image);
+```
+
+### 2. Pipeline Composition
+
+The encoder/decoder chaining allows building data processing pipelines where each stage transforms data and passes it to the next. Type safety is enforced at compile time through template parameters.
+
+### 3. Scheduled and Event-Driven Execution
+
+`AlgorithmTask` decouples the algorithm from its execution schedule. The same algorithm can be:
+- Called directly (`Process()`)
+- Run periodically (Cyclic mode for monitoring/acquisition)
+- Triggered by events (Async mode for reactive processing)
+
+### 4. Transparent CPU/GPU Dispatch
+
+The `MemoryDevice` preference and `GetPreferredDevice()` virtual allow the same algorithm interface to dispatch to CPU or GPU implementations. The `DataAllocator` transparently manages RAM/VRAM transfers, and concrete filters override `Process()` with CUDA kernels when data is on the GPU.
+
+### 5. Integration with the Object System
+
+Since `Algorithm` inherits from `Object`, algorithms gain:
+- **Properties**: serializable parameters via the `Property<T>` system, enabling persistent configuration and GUI widget generation.
+- **Signals**: `Started`/`Finished` notifications for connecting to monitoring or logging.
+- **Serialization**: save/load algorithm configuration via Boost archives.
+- **Instance naming**: `SetInstanceName()` for runtime identification in contexts.
+
+### 6. CRTP Performance for Inner Loops
+
+`VoxImageFilter` uses CRTP to dispatch to `Evaluate()` without virtual function overhead. The per-voxel evaluation runs at full speed inside OpenMP parallel loops, while the outer `Process()` method remains virtual for polymorphic use through the Algorithm interface.
+
+## Dependencies
+
+```
+Core/Object.h          — base class, properties, signals, serialization
+Core/Signal.h          — signal-slot connection infrastructure
+Core/Monitor.h         — Mutex, condition variables, ULIB_MUTEX_LOCK
+Core/Threads.h         — Thread base class for AlgorithmTask
+Core/DataAllocator.h   — MemoryDevice enum, RAM/VRAM data management
+Math/VoxImage.h        — volumetric image container
+Math/VoxImageFilter.h  — kernel-based filter framework
+```
+
+

docs/archives.md

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

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

@@ -1,94 +0,0 @@
-
-# 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/Algorithm.h

@@ -0,0 +1,263 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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_ALGORITHM_H
+#define U_CORE_ALGORITHM_H
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+
+#include "Core/Object.h"
+#include "Core/Monitor.h"
+#include "Core/Threads.h"
+#include "Core/DataAllocator.h"
+
+namespace uLib {
+
+////////////////////////////////////////////////////////////////////////////////
+//// ALGORITHM /////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @brief Algorithm is a template class for containing a functional that can be
+ * dynamically loaded as a plug-in. It derives from Object and supports
+ * properties for serialization and interactive parameter widgets.
+ *
+ * Algorithms are responsible for their own GPU synchronization: if Process()
+ * launches CUDA kernels, it must call cudaDeviceSynchronize() before returning
+ * so that the result is available to the caller or downstream algorithm.
+ *
+ * @tparam T_enc Encoder type: the input data type, or a chained algorithm
+ *               whose output is compatible with this algorithm's input.
+ * @tparam T_dec Decoder type: the output data type, or a chained algorithm
+ *               whose input is compatible with this algorithm's output.
+ */
+template <typename T_enc, typename T_dec>
+class Algorithm : public Object {
+public:
+    using EncoderType = T_enc;
+    using DecoderType = T_dec;
+
+    Algorithm()
+        : Object()
+        , m_Encoder(nullptr)
+        , m_Decoder(nullptr)
+        , m_PreferredDevice(MemoryDevice::RAM)
+    {}
+    virtual ~Algorithm() = default;
+
+    virtual const char* GetClassName() const override { return "Algorithm"; }
+
+    // Processing ///////////////////////////////////////////////////////////////
+
+    /**
+     * @brief Process input data and produce output.
+     * Override this in subclasses to implement the algorithm logic.
+     * GPU-based implementations must synchronize before returning.
+     */
+    virtual T_dec Process(const T_enc& input) = 0;
+
+    /** @brief Operator form of Process for functional chaining. */
+    T_dec operator()(const T_enc& input) { return Process(input); }
+
+    // Chaining /////////////////////////////////////////////////////////////////
+
+    void SetEncoder(Algorithm* enc) { m_Encoder = enc; }
+    Algorithm* GetEncoder() const { return m_Encoder; }
+
+    void SetDecoder(Algorithm* dec) { m_Decoder = dec; }
+    Algorithm* GetDecoder() const { return m_Decoder; }
+
+    // Device preference ////////////////////////////////////////////////////////
+
+    /**
+     * @brief Returns the preferred memory device for this algorithm.
+     * CUDA-capable algorithms should override to return VRAM when their
+     * data resides on the GPU.
+     */
+    virtual MemoryDevice GetPreferredDevice() const { return m_PreferredDevice; }
+    void SetPreferredDevice(MemoryDevice dev) { m_PreferredDevice = dev; }
+
+    /** @brief Returns true if this algorithm prefers GPU execution. */
+    bool IsGPU() const { return GetPreferredDevice() == MemoryDevice::VRAM; }
+
+    // Signals //////////////////////////////////////////////////////////////////
+
+signals:
+    virtual void Started() { ULIB_SIGNAL_EMIT(Algorithm::Started); }
+    virtual void Finished() { ULIB_SIGNAL_EMIT(Algorithm::Finished); }
+
+protected:
+    Algorithm* m_Encoder;
+    Algorithm* m_Decoder;
+    MemoryDevice m_PreferredDevice;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+//// ALGORITHM TASK ////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @brief AlgorithmTask manages the execution of an Algorithm within a
+ * scheduled context. Uses uLib::Thread for execution and uLib::Mutex for
+ * synchronization.
+ *
+ * Two execution modes:
+ *  - Cyclic:  executes Process() periodically with configurable cycle time.
+ *  - Async:   waits for Notify() or a connected signal before each execution.
+ *
+ * GPU synchronization is the algorithm's responsibility (see Algorithm::Process).
+ */
+template <typename T_enc, typename T_dec>
+class AlgorithmTask : public Thread {
+public:
+    using AlgorithmType = Algorithm<T_enc, T_dec>;
+
+    enum Mode { Cyclic, Async };
+
+    AlgorithmTask()
+        : Thread()
+        , m_Algorithm(nullptr)
+        , m_Mode(Cyclic)
+        , m_CycleTime_ms(1000)
+        , m_StopRequested(false)
+        , m_Triggered(false)
+    {}
+
+    virtual ~AlgorithmTask() { Stop(); }
+
+    virtual const char* GetClassName() const override { return "AlgorithmTask"; }
+
+    // Configuration ////////////////////////////////////////////////////////////
+
+    void SetAlgorithm(AlgorithmType* alg) { m_Algorithm = alg; }
+    AlgorithmType* GetAlgorithm() const { return m_Algorithm; }
+
+    void SetMode(Mode mode) { m_Mode = mode; }
+    Mode GetMode() const { return m_Mode; }
+
+    void SetCycleTime(int milliseconds) { m_CycleTime_ms = milliseconds; }
+    int GetCycleTime() const { return m_CycleTime_ms; }
+
+    // Lifecycle ////////////////////////////////////////////////////////////////
+
+    /**
+     * @brief Start the task execution in a separate thread (via Thread::Start).
+     * In Cyclic mode, the algorithm is executed periodically.
+     * In Async mode, call Notify() or connect a signal to trigger execution.
+     */
+    void Run(const T_enc& input) {
+        if (IsRunning()) return;
+        m_StopRequested.store(false);
+        m_Triggered.store(false);
+        m_Input = input;
+        Start();
+    }
+
+    /** @brief Stop the task execution and join the thread. */
+    void Stop() {
+        m_StopRequested.store(true);
+        ULIB_MUTEX_LOCK(m_WaitMutex, -1) {
+            m_Condition.notify_all();
+        }
+        if (IsJoinable()) Join();
+    }
+
+    // Async triggering /////////////////////////////////////////////////////////
+
+    /**
+     * @brief Notify the task to execute one iteration (Async mode).
+     * Can be called from a signal-slot connection or externally.
+     */
+    void Notify() {
+        m_Triggered.store(true);
+        ULIB_MUTEX_LOCK(m_WaitMutex, -1) {
+            m_Condition.notify_one();
+        }
+    }
+
+    /**
+     * @brief Connect an Object signal to trigger async execution.
+     * Usage: task.ConnectTrigger(sender, &SenderClass::SomeSignal);
+     */
+    template <typename Func1>
+    Connection ConnectTrigger(typename FunctionPointer<Func1>::Object* sender, Func1 sigf) {
+        return Object::connect(sender, sigf, [this]() { Notify(); });
+    }
+
+    // Signals //////////////////////////////////////////////////////////////////
+
+signals:
+    virtual void Stopped() { ULIB_SIGNAL_EMIT(AlgorithmTask::Stopped); }
+
+protected:
+    /** @brief Thread entry point — dispatches to cyclic or async loop. */
+    void Run() override {
+        if (m_Mode == Cyclic)
+            RunCyclic();
+        else
+            RunAsync();
+        Stopped();
+    }
+
+private:
+    void RunCyclic() {
+        while (!m_StopRequested.load()) {
+            if (m_Algorithm) m_Algorithm->Process(m_Input);
+            std::unique_lock<std::timed_mutex> lock(m_WaitMutex.GetNative());
+            m_Condition.wait_for(lock,
+                std::chrono::milliseconds(m_CycleTime_ms),
+                [this]() { return m_StopRequested.load(); });
+        }
+    }
+
+    void RunAsync() {
+        while (!m_StopRequested.load()) {
+            std::unique_lock<std::timed_mutex> lock(m_WaitMutex.GetNative());
+            m_Condition.wait(lock, [this]() {
+                return m_StopRequested.load() || m_Triggered.load();
+            });
+            if (m_StopRequested.load()) break;
+            m_Triggered.store(false);
+            if (m_Algorithm) m_Algorithm->Process(m_Input);
+        }
+    }
+
+    AlgorithmType* m_Algorithm;
+    Mode m_Mode;
+    int m_CycleTime_ms;
+    T_enc m_Input;
+
+    std::atomic<bool> m_StopRequested;
+    std::atomic<bool> m_Triggered;
+    Mutex m_WaitMutex;
+    std::condition_variable_any m_Condition;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_ALGORITHM_H

src/Core/Archives.h

@@ -28,8 +28,6 @@
 
 #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>
@@ -61,8 +59,6 @@ class xml_iarchive;
 class xml_oarchive;
 class text_iarchive;
 class text_oarchive;
-class hrt_iarchive;
-class hrt_oarchive;
 class log_archive;
 
 } // namespace Archive
@@ -154,7 +150,7 @@ public:
   Archive *This() { return static_cast<Archive *>(this); }
 
   template <class T>
-  const basic_pointer_iserializer *register_type(T * = nullptr) {
+  const basic_pointer_iserializer *register_type(T * = NULL) {
     const basic_pointer_iserializer &bpis = boost::serialization::singleton<
         pointer_iserializer<Archive, T>>::get_const_instance();
     this->This()->register_basic_serializer(bpis.get_basic_serializer());
@@ -165,36 +161,15 @@ 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();
   }
 };
@@ -216,7 +191,7 @@ public:
   Archive *This() { return static_cast<Archive *>(this); }
 
   template <class T>
-  const basic_pointer_oserializer *register_type(const T * = nullptr) {
+  const basic_pointer_oserializer *register_type(const T * = NULL) {
     const basic_pointer_oserializer &bpos = boost::serialization::singleton<
         pointer_oserializer<Archive, T>>::get_const_instance();
     this->This()->register_basic_serializer(bpos.get_basic_serializer());
@@ -240,6 +215,7 @@ 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();
   }
 };
@@ -264,22 +240,23 @@ 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
@@ -298,6 +275,36 @@ 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
 
@@ -305,38 +312,42 @@ 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)
-      : boost::archive::xml_iarchive_impl<xml_iarchive>(
+      : xml_iarchive_impl<xml_iarchive>(is, flags) {}
-            is, flags | boost::archive::no_header), m_flags(flags) {
+
-    if (0 == (flags & boost::archive::no_header)) {
+  using basic_xml_iarchive::load_override;
-      std::string line;
-      std::getline(is, line); // <?xml ... ?>
-      std::getline(is, line); // <!DOCTYPE ...>
-      std::getline(is, line); // <ulib_serialization ...>
-    }
-  }
 
   // Anything not an attribute should be a name value pair as nvp or hrp
   typedef boost::archive::detail::common_iarchive<Archive>
@@ -355,9 +366,6 @@ public:
   // 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 ..
-  // Note: using base::load_override covers all basic_xml_iarchive overloads
-  // transitively, so a separate 'using basic_xml_iarchive::load_override'
-  // is redundant and creates ambiguity with clang.
   using base::load_override;
 
   void load_override(const char *str) {
@@ -365,9 +373,13 @@ public:
     //        sr >> str;
   }
 
-  virtual ~xml_iarchive() {}
+  ~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> {
@@ -377,39 +389,31 @@ 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>(
+      : boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
-            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");
-    }
-  }
 
-  virtual ~xml_oarchive() {
+  // example of implementing save_override for const char* //
-    if (0 == (m_flags & boost::archive::no_header)) {
+  //    void save_override(const char *t, int) {
-      this->This()->put("</ulib_serialization>\n");
+  //        std::cout << "found char: " << t << "\n";
-    }
+  //    }
-  }
 
   using basic_xml_oarchive::save_override;
 
@@ -431,6 +435,8 @@ public:
     // Do not save any human decoration string //
     //        basic_text_oprimitive::save(str);
   }
+
+  ~xml_oarchive() {}
 };
 
 // typedef boost::archive::detail::polymorphic_oarchive_route<
@@ -465,11 +471,15 @@ public:
     sr >> str;
   }
 
-  virtual ~text_iarchive() {}
+  ~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;
@@ -487,9 +497,13 @@ public:
 
   void save_override(const char *str) { basic_text_oprimitive::save(str); }
 
-  virtual ~text_oarchive() {}
+  ~text_oarchive() {}
 };
 
+// typedef boost::archive::detail::polymorphic_oarchive_route<
+// boost::archive::text_oarchive_impl<text_oarchive>
+//> polymorphic_text_oarchive;
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -526,7 +540,7 @@ public:
     sr >> str;
   }
 
-  virtual ~hrt_iarchive() {}
+  ~hrt_iarchive() {};
 };
 
 class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
@@ -562,7 +576,7 @@ public:
     *this << "\n";
   }
 
-  virtual ~hrt_oarchive() {}
+  ~hrt_oarchive() {}
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -591,9 +605,17 @@ public:
   }
 
   template <class T> void save_override(const T &t) {
-    base::save_override(boost::serialization::make_nvp(nullptr, t));
+    base::save_override(boost::serialization::make_nvp(NULL, 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);
   }
@@ -618,10 +640,12 @@ public:
   log_archive(std::ostream &os, unsigned int flags = 0)
       : boost::archive::xml_oarchive_impl<log_archive>(
             os, flags | boost::archive::no_header) {}
-
-  virtual ~log_archive() {}
 };
 
+// typedef boost::archive::detail::polymorphic_oarchive_route<
+// boost::archive::xml_oarchive_impl<log_archive>
+//> polymorphic_log_archive;
+
 } // namespace Archive
 
 } // namespace uLib
@@ -634,4 +658,10 @@ 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

@@ -1,5 +1,6 @@
 
 set(HEADERS
+    Algorithm.h
     Archives.h
     Array.h
     Collection.h 
@@ -58,7 +59,6 @@ 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/Debug.h

@@ -38,76 +38,6 @@
 #include <boost/any.hpp>
 
 
-
-/**
- * @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 {
 
 
@@ -177,6 +107,7 @@ public:
 
 
 
+
 class Debug {
     typedef detail::DebugAdapterInterface AdapterInterface;
     typedef SmartPointer<detail::DebugAdapterInterface> Adapter;

src/Core/Object.cpp

@@ -79,7 +79,6 @@ 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);
     }
@@ -99,11 +98,6 @@ PropertyBase* Object::GetProperty(const std::string& name) const {
     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.
 
@@ -116,11 +110,18 @@ void Object::serialize(ArchiveT &ar, const unsigned int 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);
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

src/Core/Object.h

@@ -52,7 +52,6 @@ class polymorphic_oarchive;
 namespace uLib {
 
 class PropertyBase;
-class ObjectsContext;
 
 class Version {
 public:
@@ -78,8 +77,7 @@ public:
   Object(const Object &copy);
   virtual ~Object();
 
-  virtual const char * GetClassName() const { return type_name(); }
+  virtual const char * GetClassName() const { return "Object"; }
-  virtual const char * type_name() const { return "Object"; }
 
   const std::string& GetInstanceName() const;
   void SetInstanceName(const std::string& name);
@@ -97,18 +95,12 @@ public:
   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 //
 
   // FIXX !!!
   virtual void DeepCopy(const Object &copy);
 
-  /** @brief Returns a nested context for children objects, if any. */
-  virtual ObjectsContext* GetChildren() { return nullptr; }
-
   ////////////////////////////////////////////////////////////////////////////
   // SERIALIZATION //
 
@@ -137,7 +129,6 @@ public:
 
   signals:
   virtual void Updated();
-  virtual void PropertyUpdated();
 
   // Qt4 style connector //
   static bool connect(const Object *ob1, const char *signal_name,

src/Core/ObjectsContext.h

@@ -9,13 +9,12 @@ namespace uLib {
 /**
  * @brief ObjectsContext represents a collection of Object instances.
  */
-class ObjectsContext : virtual public Object {
+class ObjectsContext : public Object {
 public:
     ObjectsContext();
     virtual ~ObjectsContext();
 
-    uLibTypeMacro(ObjectsContext, Object)
+    virtual const char * GetClassName() const { return "ObjectsContext"; }
-    virtual ObjectsContext* GetChildren() override { return this; }
 
     /**
      * @brief Adds an object to the context.

src/Core/Property.h

@@ -36,14 +36,6 @@ public:
   }
   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();
@@ -54,22 +46,15 @@ public:
   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_oarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) = 0;
-  virtual void serialize(Archive::log_archive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::log_archive & ar, const unsigned int version) = 0;
 };
 
-
-
-
-
-
-
-
 /**
  * @brief Template class for typed properties.
  */
@@ -78,8 +63,7 @@ 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_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);
       }
@@ -87,8 +71,7 @@ public:
 
   // 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_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);
       }
@@ -120,64 +103,15 @@ public:
 
   // 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;
+    if (*m_value != value) {
-    ValidateT<T>(val);
+      *m_value = value;
-    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) {
@@ -203,11 +137,6 @@ public:
   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;
@@ -215,12 +144,6 @@ private:
   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;
 };
 
 /**
@@ -235,7 +158,6 @@ typedef Property<float>         FloatProperty;
 typedef Property<double>        DoubleProperty;
 typedef Property<Bool_t>      BoolProperty;
 
-
 /**
  * @brief Property specialized for enumerations, providing labels for GUI representations.
  */
@@ -252,16 +174,6 @@ private:
   std::vector<std::string> m_Labels;
 };
 
-
-
-
-
-
-
-
-
-
-
 /**
  * @brief Macro to simplify property declaration within a class.
  * Usage: ULIB_PROPERTY(float, Width, 1.0f)
@@ -325,27 +237,6 @@ public:
     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);
         }
     }
@@ -354,16 +245,6 @@ public:
     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);
         }
     }
@@ -404,34 +285,12 @@ 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); }
+    { uLib::Archive::property_register_archive _ar_tmp(&(obj)); (obj).serialize(_ar_tmp, 0); }
-
-/**
- * @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

src/Core/Serializable.h

@@ -71,39 +71,21 @@ namespace serialization {
 // ACCESS 2 //
 template <class T> struct access2 {};
 
+// NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
 template <class T>
 class hrp : public boost::serialization::wrapper_traits<hrp<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(const char *name_, T &t, const char* units_ = nullptr) 
+  explicit hrp(const char *name_, T &t, const char* units_ = nullptr) : m_name(name_), m_units(units_), m_value(t) {}
-    : 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>
@@ -117,159 +99,47 @@ public:
   }
 };
 
-template <class 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);
 }
 
-// Specialization for rvalues (value-based storage)
 template <class T>
-inline hrp_val<T> make_hrp(const char *name, T &&t, const char* units = nullptr) {
+class hrp_enum : public boost::serialization::wrapper_traits<hrp_enum<T>> {
-  return hrp_val<T>(name, t, units);
+  const char *m_name;
-}
+  const char *m_units;
+  T &m_value;
+  std::vector<std::string> m_labels;
+
+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) {}
+
+  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; }
+
+  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>
 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)
+#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
-template <class T>
+#define HRPU(name, units) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name, units)
-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
@@ -289,41 +159,7 @@ namespace uLib {
 
 #define _AR_OP(r, data, elem) data &BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
 
-// NAME VALUE PAIR //
+#define NVP(data) BOOST_SERIALIZATION_NVP(data)
-#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
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -351,7 +187,7 @@ using boost::serialization::make_hrp_enum;
 #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_HR_(_name)
+#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
 #endif
 
 #define ULIB_SERIALIZE_ACCESS                                                  \
@@ -365,13 +201,13 @@ using boost::serialization::make_hrp_enum;
   BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
 
 #define _SERIALIZE_IMPL_SEQ                                                                   \
-  (uLib::Archive::text_iarchive) \
+  (uLib::Archive::text_iarchive)(uLib::Archive::text_oarchive)(                               \
-  (uLib::Archive::text_oarchive) \
+      uLib::Archive::                                                                         \
-  (uLib::Archive::hrt_iarchive)  \
+          hrt_iarchive)(uLib::Archive::                                                       \
-  (uLib::Archive::hrt_oarchive)  \
+                            hrt_oarchive)(uLib::Archive::                                     \
-  (uLib::Archive::xml_iarchive)  \
+                                              xml_iarchive)(uLib::Archive::                   \
-  (uLib::Archive::xml_oarchive)  \
+                                                                xml_oarchive)(uLib::Archive:: \
-  (uLib::Archive::log_archive)
+                                                                                  log_archive)
 
 /** Solving virtual class check problem */
 #define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived)               \
@@ -442,11 +278,6 @@ using boost::serialization::make_hrp_enum;
   template <class ArchiveT>                                                    \
   void _Ob::save_override(ArchiveT &ar, const unsigned int version)
 
-
-
-
-
-  
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -551,8 +382,7 @@ using boost::serialization::make_hrp_enum;
   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>                     \
+  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }                                                          \
-  (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) {           \
@@ -577,16 +407,8 @@ using boost::serialization::make_hrp_enum;
   void boost::serialization::access2<_Ob>::save_override(                      \
       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

@@ -95,8 +95,6 @@ namespace uLib {
 
 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;

src/Core/Types.h

@@ -182,7 +182,7 @@ typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
                                                                                \
 public:                                                                        \
   typedef type_info::BaseClass BaseClass;                                      \
-  virtual const char *type_name() const override { return type_info::name; }            \
+  virtual const char *type_name() const { return type_info::name; }            \
   /**/
 
 /**

src/Core/testing/AlgorithmTest.cpp

@@ -0,0 +1,206 @@
+#include "Core/Algorithm.h"
+#include <iostream>
+#include <atomic>
+#include <cassert>
+
+using namespace uLib;
+
+////////////////////////////////////////////////////////////////////////////////
+// Test algorithms
+
+class DoubleAlgorithm : public Algorithm<int, int> {
+public:
+    const char* GetClassName() const override { return "DoubleAlgorithm"; }
+    int Process(const int& input) override {
+        m_CallCount++;
+        return input * 2;
+    }
+    std::atomic<int> m_CallCount{0};
+};
+
+class StringifyAlgorithm : public Algorithm<int, std::string> {
+public:
+    const char* GetClassName() const override { return "StringifyAlgorithm"; }
+    std::string Process(const int& input) override {
+        return std::to_string(input);
+    }
+};
+
+// Signal source to test ConnectTrigger
+class TriggerSource : public Object {
+public:
+    const char* GetClassName() const override { return "TriggerSource"; }
+signals:
+    virtual void DataReady() { ULIB_SIGNAL_EMIT(TriggerSource::DataReady); }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Tests
+
+void TestBasicProcess() {
+    std::cout << "Testing basic Algorithm::Process..." << std::endl;
+    DoubleAlgorithm alg;
+    assert(alg.Process(5) == 10);
+    assert(alg.Process(-3) == -6);
+    assert(alg.Process(0) == 0);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestOperatorCall() {
+    std::cout << "Testing Algorithm::operator()..." << std::endl;
+    DoubleAlgorithm alg;
+    assert(alg(7) == 14);
+    assert(alg(0) == 0);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestEncoderDecoderChain() {
+    std::cout << "Testing encoder/decoder chain pointers..." << std::endl;
+    DoubleAlgorithm a, b;
+    a.SetDecoder(&b);
+    b.SetEncoder(&a);
+    assert(a.GetDecoder() == &b);
+    assert(b.GetEncoder() == &a);
+    assert(a.GetEncoder() == nullptr);
+    assert(b.GetDecoder() == nullptr);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestAlgorithmSignals() {
+    std::cout << "Testing Algorithm signals..." << std::endl;
+    DoubleAlgorithm alg;
+    bool started = false;
+    bool finished = false;
+    Object::connect(&alg, &DoubleAlgorithm::Started, [&]() { started = true; });
+    Object::connect(&alg, &DoubleAlgorithm::Finished, [&]() { finished = true; });
+    alg.Started();
+    alg.Finished();
+    assert(started);
+    assert(finished);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestCyclicTask() {
+    std::cout << "Testing AlgorithmTask cyclic mode (Thread-based)..." << std::endl;
+    DoubleAlgorithm alg;
+    AlgorithmTask<int, int> task;
+    task.SetAlgorithm(&alg);
+    task.SetMode(AlgorithmTask<int, int>::Cyclic);
+    task.SetCycleTime(50);
+
+    assert(!task.IsRunning());
+    task.Run(5);
+
+    // Let it run for ~200ms -> expect ~4 cycles
+    Thread::Sleep(220);
+    task.Stop();
+
+    assert(!task.IsRunning());
+    int count = alg.m_CallCount.load();
+    std::cout << "  Cyclic iterations: " << count << std::endl;
+    assert(count >= 3 && count <= 6);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestAsyncTask() {
+    std::cout << "Testing AlgorithmTask async mode (Mutex + condition_variable)..." << std::endl;
+    DoubleAlgorithm alg;
+    AlgorithmTask<int, int> task;
+    task.SetAlgorithm(&alg);
+    task.SetMode(AlgorithmTask<int, int>::Async);
+
+    task.Run(42);
+    Thread::Sleep(50); // let the thread start and wait
+
+    // Trigger 3 notifications
+    for (int i = 0; i < 3; ++i) {
+        task.Notify();
+        Thread::Sleep(30);
+    }
+
+    task.Stop();
+    int count = alg.m_CallCount.load();
+    std::cout << "  Async invocations: " << count << std::endl;
+    assert(count == 3);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestConnectTrigger() {
+    std::cout << "Testing AlgorithmTask::ConnectTrigger (signal-slot async)..." << std::endl;
+    DoubleAlgorithm alg;
+    AlgorithmTask<int, int> task;
+    task.SetAlgorithm(&alg);
+    task.SetMode(AlgorithmTask<int, int>::Async);
+
+    TriggerSource source;
+    task.ConnectTrigger(&source, &TriggerSource::DataReady);
+
+    task.Run(10);
+    Thread::Sleep(50);
+
+    // Emit signal 3 times
+    for (int i = 0; i < 3; ++i) {
+        source.DataReady();
+        Thread::Sleep(30);
+    }
+
+    task.Stop();
+    int count = alg.m_CallCount.load();
+    std::cout << "  Signal-triggered invocations: " << count << std::endl;
+    assert(count == 3);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestTaskStoppedSignal() {
+    std::cout << "Testing AlgorithmTask Stopped signal..." << std::endl;
+    DoubleAlgorithm alg;
+    AlgorithmTask<int, int> task;
+    task.SetAlgorithm(&alg);
+    task.SetMode(AlgorithmTask<int, int>::Cyclic);
+    task.SetCycleTime(20);
+
+    std::atomic<bool> stopped{false};
+    Object::connect(&task, &AlgorithmTask<int, int>::Stopped,
+                    [&]() { stopped.store(true); });
+
+    task.Run(1);
+    Thread::Sleep(50);
+    task.Stop();
+    Thread::Sleep(50);
+
+    assert(stopped.load());
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestClassName() {
+    std::cout << "Testing GetClassName..." << std::endl;
+    DoubleAlgorithm alg;
+    AlgorithmTask<int, int> task;
+    assert(std::string(alg.GetClassName()) == "DoubleAlgorithm");
+    assert(std::string(task.GetClassName()) == "AlgorithmTask");
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestDifferentTypes() {
+    std::cout << "Testing Algorithm with different enc/dec types..." << std::endl;
+    StringifyAlgorithm alg;
+    assert(alg.Process(42) == "42");
+    assert(alg.Process(-1) == "-1");
+    assert(alg(100) == "100");
+    std::cout << "  Passed." << std::endl;
+}
+
+int main() {
+    TestBasicProcess();
+    TestOperatorCall();
+    TestEncoderDecoderChain();
+    TestAlgorithmSignals();
+    TestDifferentTypes();
+    TestCyclicTask();
+    TestAsyncTask();
+    TestConnectTrigger();
+    TestTaskStoppedSignal();
+    TestClassName();
+    std::cout << "All Algorithm tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/CMakeLists.txt

@@ -29,7 +29,7 @@ set( TESTS
         OpenMPTest
         TeamTest
         AffinityTest
-        ReadOnlyPropertyTest
+        AlgorithmTest
 )
 
 set(LIBRARIES

src/Core/testing/PropertiesTest.cpp

@@ -23,138 +23,74 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+
+
+
 #include <iostream>
-#include <fstream>
+
-#include <string>
+#include <boost/signals2/signal.hpp>
+
 
 #include "Core/Object.h"
-#include "Core/Property.h"
-#include "Core/Archives.h"
-#include "Core/Serializable.h"
 #include "testing-prototype.h"
 
-using namespace uLib;
+#define emit
+
+
+
+
+template <typename T, bool copyable = true>
+class property
+{
+    typedef boost::signals2::signal<void(const property<T>& )> signal_t;
 
-/**
- * @brief A test class to demonstrate property registration via SERIALIZE_OBJECT.
- */
-class TestObject : public Object {
 public:
-    uLibTypeMacro(TestObject, Object)
+    property() : m_changed(new signal_t) {}
+    property(const T in) : value(in) , m_changed(new signal_t) {}
 
-    TestObject() : m_Value(10.5f), m_Status("Initialized"), m_Counter(0) {}
+    inline operator T const & () const { return value; }
-
+    inline operator T & () { return value; }
-    float m_Value;
+    inline T & operator = (const T &i) { value = i; return value; }
-    std::string m_Status;
+    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }    // Assign exact identical types only.
-    int m_Counter;
+    inline signal_t & valueChanged() { return *m_changed; }
-
-    // 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;
 };
 
 
-class TestObject2 : public TestObject {
+//template <typename T>
-public:
+//class property <T,false> {
-    uLibTypeMacro(TestObject2, TestObject)
+//    typedef boost::signals2::signal<void( T )> signal_t;
 
-    TestObject2() : TestObject(), m_Value2(20.5f) {}
+//public:
+//    property() : m_changed() {}
+//    property(const T in) : value(in) , m_changed() {}
 
-    float m_Value2;
+//    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()
+{    
 
-    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/PropertySystemTest.cpp

@@ -8,12 +8,13 @@ using namespace uLib;
 
 class TestObject : public Object {
 public:
-  uLibTypeMacro(TestObject, Object)
   TestObject() : Object(), 
     IntProp(this, "IntProp", 10),
     StringProp(this, "StringProp", "Initial") 
   {}
 
+  virtual const char* GetClassName() const override { return "TestObject"; }
+
   Property<int> IntProp;
   Property<std::string> StringProp;
 };

src/Core/testing/PropertyTypesTest.cpp

@@ -9,9 +9,10 @@ using namespace uLib;
 
 class TestObject : public Object {
 public:
-  uLibTypeMacro(TestObject, Object)
   TestObject() : Object() {}
 
+  virtual const char* GetClassName() const override { return "TestObject"; }
+
   // Use new typedefs
   StringProperty  StringProp = StringProperty(this, "StringProp", "Initial");
   IntProperty     IntProp    = IntProperty(this, "IntProp", 42);

src/Core/testing/ReadOnlyPropertyTest.cpp

@@ -1,82 +0,0 @@
-#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,33 +67,10 @@ 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() {
-  BEGIN_TESTING(DreadDiamond Serialization)
+  A o;
 
-  D o;
+  Archive::xml_oarchive(std::cout) << NVP(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,19 +143,22 @@ 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());
-  // TEST1(testing_hrt_class());
+  //    testing_hrt_class(); ///// << ERRORE in HRT with properties
 
   END_TESTING;
 }

src/Core/testing/testing-prototype.h

@@ -33,7 +33,5 @@ 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.h

@@ -40,10 +40,12 @@ namespace uLib {
 
 class DetectorChamber : public ContainerBox {
 
+  typedef ContainerBox BaseClass;
+  
+
 public:
-  uLibTypeMacro(DetectorChamber, ContainerBox)
-
 
+  virtual const char * GetClassName() const { return "DetectorChamber"; }
 
   DetectorChamber() : BaseClass() {
     m_ProjectionPlane.origin = HPoint3f(0, 0, 0);

src/HEP/Geant/CMakeLists.txt

@@ -27,8 +27,6 @@ set(SOURCES
     Scene.cpp
     Solid.cpp
     EmitterPrimary.cpp
-    Matter.cpp
-    GeantRegistration.cpp
     DetectorConstruction.cpp
     PhysicsList.cpp
     ActionInitialization.cpp

src/HEP/Geant/EmitterPrimary.hh

@@ -23,10 +23,11 @@ class G4Event;
 namespace uLib {
 namespace Geant {
 
-class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransform
+class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public Object, public AffineTransform
 {
   public:
-    uLibTypeMacro(EmitterPrimary, Object)
+
+    virtual const char* GetClassName() const override { return "Geant.EmitterPrimary"; }
 
     EmitterPrimary();    
     virtual ~EmitterPrimary();
@@ -46,7 +47,8 @@ class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransf
 class SkyPlaneEmitterPrimary : public EmitterPrimary
 {
   public:
-    uLibTypeMacro(SkyPlaneEmitterPrimary, EmitterPrimary)
+
+    virtual const char* GetClassName() const override { return "Geant.SkyPlaneEmitterPrimary"; }
 
     SkyPlaneEmitterPrimary();
     virtual ~SkyPlaneEmitterPrimary();
@@ -67,7 +69,8 @@ class SkyPlaneEmitterPrimary : public EmitterPrimary
 class CylinderEmitterPrimary : public EmitterPrimary
 {
   public:
-    uLibTypeMacro(CylinderEmitterPrimary, EmitterPrimary)
+
+    virtual const char* GetClassName() const override { return "Geant.CylinderEmitterPrimary"; }
 
     CylinderEmitterPrimary();
     virtual ~CylinderEmitterPrimary();
@@ -95,7 +98,8 @@ class CylinderEmitterPrimary : public EmitterPrimary
 class QuadMeshEmitterPrimary : public EmitterPrimary
 {
   public:
-    uLibTypeMacro(QuadMeshEmitterPrimary, EmitterPrimary)
+
+    virtual const char* GetClassName() const override { return "Geant.QuadMeshEmitterPrimary"; }
 
     QuadMeshEmitterPrimary();    
     virtual ~QuadMeshEmitterPrimary();

src/HEP/Geant/GeantEvent.h

@@ -50,7 +50,8 @@ class SteppingAction;
 class GeantEvent : public Object {
   
 public:
-  uLibTypeMacro(GeantEvent, Object)
+
+  virtual const char* GetClassName() const override { return "Geant.GeantEvent"; }
 
   /// A single interaction step along the muon path.
   struct Delta {

src/HEP/Geant/GeantRegistration.cpp

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

@@ -1,21 +0,0 @@
-
-#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,10 +29,9 @@
 #define MATTER_H
 
 #include "Core/Object.h"
-#include <Geant4/G4Material.hh>
-#include <Geant4/G4NistManager.hh>
 
 class G4Element;
+class G4Material;
 
 namespace uLib {
 namespace Geant {
@@ -56,53 +55,18 @@ private:
 //// MATERIAL //////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-// TODO: finish from G4NistMaterialBuilder
 
 class Material : public Object {
 public:
-    uLibTypeMacro(Material, Object)
 
-    enum State  {
+    virtual const char* GetClassName() const override { return "Geant.Material"; }
-        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.h

@@ -43,7 +43,8 @@ class EmitterPrimary;
 
 class Scene : public Object {
 public:
-  uLibTypeMacro(Scene, Object)
+
+  virtual const char* GetClassName() const override { return "Geant.Scene"; }
 
   Scene();
   ~Scene();

src/HEP/Geant/Solid.cpp

@@ -146,9 +146,6 @@ 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)) {
     }
@@ -176,15 +173,9 @@ 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_Solid = new G4Box(name, 1,1,1);
-  m_ContainerBox = box;
+  m_Object = box;
   Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
   if (m_Logical) {
     m_Logical->SetSolid(m_Solid);
@@ -193,16 +184,16 @@ BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
 }
 
 void BoxSolid::Update() {
-  if (m_ContainerBox) {
+  if (m_Object) {
-    Vector3f size = m_ContainerBox->GetSize();
+    Vector3f size = m_Object->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_ContainerBox->GetPosition();
+    Vector3f pos = m_Object->GetPosition();
-    Matrix3f rot = m_ContainerBox->GetRotation();
+    Matrix3f rot = m_Object->GetRotation();
 
     // 2. Center = Corner + Rotation * (Half-Size)
     // We must rotate the offset vector because uLib box can be rotated.
@@ -214,9 +205,6 @@ void BoxSolid::Update() {
     
     this->SetTransform(t.GetMatrix());
   }
-
-
-
 }
 
 

src/HEP/Geant/Solid.h

@@ -43,7 +43,8 @@ namespace Geant {
 
 class Solid : public Object {
 public:
-  uLibTypeMacro(Solid, Object)
+
+  virtual const char* GetClassName() const override { return "Geant.Solid"; }
 
   Solid();
   Solid(const char *name);
@@ -51,7 +52,6 @@ public:
 
   void SetNistMaterial(const char *name);
   void SetMaterial(G4Material *material);
-  
   void SetSizeUnit(const char *unit);
   // Implementiamo SetParent qui, per tutti.
   virtual void SetParent(Solid *parent); 
@@ -69,14 +69,6 @@ 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;
@@ -92,10 +84,11 @@ protected:
 
 
 class TessellatedSolid : public Solid {
+  typedef Solid BaseClass;
 public:
-  uLibTypeMacro(TessellatedSolid, Solid)
 
-  TessellatedSolid();
+  virtual const char* GetClassName() const override { return "Geant.TessellatedSolid"; }
+
   TessellatedSolid(const char *name);
   void SetMesh(TriangleMesh &mesh);
   uLibGetMacro(Solid, G4TessellatedSolid *) 
@@ -117,27 +110,22 @@ private :
 
 
 class BoxSolid : public Solid {
+  typedef Solid BaseClass;
 
 public:
-  uLibTypeMacro(BoxSolid, Solid)
 
-  BoxSolid(const char *name = "");
+  virtual const char* GetClassName() const override { return "Geant.BoxSolid"; }
+
   BoxSolid(const char *name, ContainerBox *box);
   virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
   
-  ContainerBox* GetObject() const { return m_ContainerBox; }
+  ContainerBox* GetObject() const { return m_Object; }
-
-  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_ContainerBox;
+  ContainerBox *m_Object;
   G4Box *m_Solid;
 };
 

src/Math/Assembly.cpp

@@ -21,44 +21,27 @@ namespace uLib {
 
 Assembly::Assembly()
     : ObjectsContext(),
-      TRS(),
+      AffineTransform(),
       m_BBoxMin(Vector3f::Zero()),
       m_BBoxMax(Vector3f::Zero()),
       m_ShowBoundingBox(false),
-      m_GroupSelection(true) {
+      m_GroupSelection(true) {}
-}
 
 Assembly::Assembly(const Assembly &copy)
     : ObjectsContext(copy),
-      TRS(copy),
+      AffineTransform(copy),
       m_BBoxMin(copy.m_BBoxMin),
       m_BBoxMax(copy.m_BBoxMax),
       m_ShowBoundingBox(copy.m_ShowBoundingBox),
       m_GroupSelection(copy.m_GroupSelection) {}
 
-Assembly::~Assembly() {
+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) {
@@ -66,15 +49,7 @@ void Assembly::RemoveObject(Object *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() {
@@ -89,11 +64,12 @@ void Assembly::ComputeBoundingBox() {
     m_BBoxMin = Vector3f(inf, inf, inf);
     m_BBoxMax = Vector3f(-inf, -inf, -inf);
 
+    Matrix4f invAsm = this->GetWorldMatrix().inverse();
+
     for (Object *obj : objects) {
         if (auto *box = dynamic_cast<ContainerBox *>(obj)) {
-            // ContainerBox: wm is matrix from unit cube [0,1] to local space
+            // ContainerBox: wm is matrix from unit cube [0,1] to assembly base
-            // Since it is parented to 'this', GetMatrix() is sufficient.
+            Matrix4f m = invAsm * box->GetWorldMatrix();
-            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;
@@ -106,7 +82,7 @@ void Assembly::ComputeBoundingBox() {
             }
         } else if (auto *cyl = dynamic_cast<Cylinder *>(obj)) {
             // Cylinder: centered [-1, 1] radial, [-0.5, 0.5] height
-            Matrix4f m = cyl->GetMatrix();
+            Matrix4f m = invAsm * cyl->GetWorldMatrix();
             for (int i = 0; i < 8; ++i) {
                 float x = (i & 1) ? 1.0f : -1.0f;
                 float y = (i & 2) ? 0.5f : -0.5f;
@@ -122,7 +98,7 @@ void Assembly::ComputeBoundingBox() {
             subAsm->ComputeBoundingBox();
             Vector3f subMin, subMax;
             subAsm->GetBoundingBox(subMin, subMax);
-            Matrix4f m = subAsm->GetMatrix();
+            Matrix4f m = invAsm * subAsm->GetWorldMatrix();
             for (int i = 0; i < 8; ++i) {
                 float x = (i & 1) ? subMax(0) : subMin(0);
                 float y = (i & 2) ? subMax(1) : subMin(1);

src/Math/Assembly.h

@@ -43,21 +43,14 @@ namespace uLib {
  * 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 {
+class Assembly : public ObjectsContext, public AffineTransform {
 public:
-    uLibTypeMacro(Assembly, ObjectsContext, TRS)
+    virtual const char *GetClassName() const override { return "Assembly"; }
-    
 
     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;
 
@@ -96,13 +89,10 @@ public:
 
 signals:
     virtual void Updated() override {
-        if (m_InUpdated) return; 
+        if (m_InUpdated) return;  // break signal recursion
         m_InUpdated = true;
-        
-        // Synchronize TRS part
-        this->TRS::Updated();
-        
         this->ComputeBoundingBox();
+        ULIB_SIGNAL_EMIT(Assembly::Updated);
         m_InUpdated = false;
     }
 
@@ -112,9 +102,6 @@ private:
     bool     m_ShowBoundingBox;
     bool     m_GroupSelection;
     bool     m_InUpdated = false;
-    std::map<Object*, Connection> m_ChildConnections;
-
-    ULIB_DECLARE_PROPERTIES(Assembly)
 };
 
 } // namespace uLib

src/Math/ContainerBox.h

@@ -29,31 +29,31 @@
 #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 TRS, which defines its parent
+ * ContainerBox inherits from AffineTransform, 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 TRS {
+class ContainerBox : public AffineTransform, public Object {
 
-  uLibTypeMacro(ContainerBox, TRS)
+  typedef AffineTransform BaseClass;
-  ULIB_SERIALIZE_ACCESS
-  ULIB_DECLARE_PROPERTIES(ContainerBox)
 
 public:
+  ////////////////////////////////////////////////////////////////////////////
+  // PROPERTIES //
+  Property<Vector3f> p_Size;
+  Property<Vector3f> p_Origin;
+  virtual const char * GetClassName() const { return "ContainerBox"; }
 
   /**
    * @brief Default constructor.
@@ -61,9 +61,10 @@ public:
    */
   ContainerBox()
       : m_LocalT(this), // BaseClass is Parent of m_LocalTransform
-        Size(1.0f, 1.0f, 1.0f),
+        p_Size(this, "Size", Vector3f(1.0f, 1.0f, 1.0f)),
-        Origin(0.0f, 0.0f, 0.0f) {
+        p_Origin(this, "Origin", Vector3f(0.0f, 0.0f, 0.0f)) {
-    this->Sync();
+    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
+    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
   }
 
   /**
@@ -72,9 +73,11 @@ public:
    */
   ContainerBox(const Vector3f &size)
       : m_LocalT(this),
-        Size(size),
+        p_Size(this, "Size", size),
-        Origin(0.0f, 0.0f, 0.0f) {
+        p_Origin(this, "Origin", Vector3f(0.0f, 0.0f, 0.0f)) {
-    this->Sync();
+    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
+    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
+    this->SetSize(size);
   }
 
   /**
@@ -82,21 +85,13 @@ public:
    * @param copy The ContainerBox instance to copy from.
    */
   ContainerBox(const ContainerBox &copy)
-      : m_LocalT(this), // Reset parent to the new object
+      : m_LocalT(copy.m_LocalT), // Copy local transform state
-        TRS(copy),
+        AffineTransform(copy),
-        Size(copy.Size),
+        p_Size(this, "Size", copy.p_Size),
-        Origin(copy.Origin) {
+        p_Origin(this, "Origin", copy.p_Origin) {
-    this->Sync();
+    m_LocalT.SetParent(this); // Reset parent to the new object
-  }
+    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
-
+    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
-  // /**
-  //  * @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));
   }
 
   /**
@@ -104,7 +99,7 @@ public:
    * @param v The origin position vector.
    */
   void SetOrigin(const Vector3f &v) { 
-    Origin = v;
+    p_Origin = v;
     m_LocalT.SetPosition(v); 
   }
 
@@ -120,7 +115,7 @@ public:
    * @param v The size vector (width, height, depth).
    */
   void SetSize(const Vector3f &v) {
-    Size = v;
+    p_Size = v;
     Vector3f pos = this->GetOrigin();
     m_LocalT = AffineTransform(this); // regenerate local transform
     m_LocalT.Scale(v);
@@ -199,43 +194,33 @@ public:
   }
 
   /** Translate using transformation chain */
-  using AffineTransform::Translate;
+  using BaseClass::Translate;
 
   /** Rotate using transformation chain */
-  using AffineTransform::Rotate;
+  using BaseClass::Rotate;
 
   /** Scale using transformation chain */
-  using AffineTransform::Scale;
+  using BaseClass::Scale;
 
 signals:
 
-  /** Signal emitted when properties change */
+  // signal to emit when the box is updated //
-  virtual void Updated() override { 
+  virtual void Updated() override { ULIB_SIGNAL_EMIT(ContainerBox::Updated); }
-      // 1. Synchronize local box part (Size/Origin -> m_LocalT)
-      this->Sync();
 
-      // 2. Synchronize TRS part (position/rotation/scaling -> m_T) and emit signal
+private slots:
-      this->TRS::Updated();
+  void SyncSize() {
-      
+      this->SetSize(p_Size);
-      // std::cout << "ContainerBox::Updated()" << std::endl;
   }
 
-private:
+  void SyncOrigin() {
-  /** Synchronizes internal transformation with properties */
+      this->SetOrigin(p_Origin);
-  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

@@ -39,27 +39,19 @@ namespace uLib {
  * 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 {
+class Cylinder : public AffineTransform, public Object {
-
-    uLibTypeMacro(Cylinder, TRS)
-    ULIB_DECLARE_PROPERTIES(Cylinder)
 
 public:
+    uLibTypeMacro(Cylinder, Object)
 
-    /**
+    virtual const char * GetClassName() const override { return "Cylinder"; }
-     * @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();
+        ULIB_ACTIVATE_PROPERTIES(*this);
+        UpdateLocalMatrix();
     }
 
     /**
@@ -67,15 +59,17 @@ public:
      */
     Cylinder(float radius, float height, int axis = 1) 
         : m_LocalT(this), Radius(radius), Height(height), Axis(axis) {
-        this->Sync();
+        ULIB_ACTIVATE_PROPERTIES(*this);
+        UpdateLocalMatrix();
     }
 
     /**
      * @brief Copy constructor.
      */
     Cylinder(const Cylinder &copy)
-        : m_LocalT(this), TRS(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
+        : m_LocalT(this), AffineTransform(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
-        this->Sync();
+        ULIB_ACTIVATE_PROPERTIES(*this);
+        this->UpdateLocalMatrix();
     }
 
     /**
@@ -85,14 +79,13 @@ public:
     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 & HRP(Axis);
-        ar & NVP("TRS", boost::serialization::base_object<TRS>(*this));
     }
 
     /** Sets the radius of the cylinder */
     inline void SetRadius(float r) { 
         Radius = r; 
-        this->Sync(); 
+        UpdateLocalMatrix(); 
     }
     
     /** Gets the radius of the cylinder */
@@ -101,7 +94,7 @@ public:
     /** Sets the height of the cylinder */
     inline void SetHeight(float h) { 
         Height = h; 
-        this->Sync(); 
+        UpdateLocalMatrix(); 
     }
     
     /** Gets the height of the cylinder */
@@ -110,7 +103,7 @@ public:
     /** Sets the main axis (0=X, 1=Y, 2=Z) */
     inline void SetAxis(int axis) {
         Axis = axis;
-        this->Sync();
+        UpdateLocalMatrix();
     }
 
     /** Gets the main axis */
@@ -164,36 +157,25 @@ public:
         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->UpdateLocalMatrix();
-        this->Sync();
+        ULIB_SIGNAL_EMIT(Cylinder::Updated); 
-        
-        // 2. Synchronize TRS part (position/rotation/scaling -> m_T) and emit signal
-        this->TRS::Updated();
     }
 
 private:
-  /** Synchronizes internal transformation with properties */
+    /** Recalculates the internal local matrix based on dimensions and axis */
-  void Sync() {
+    void UpdateLocalMatrix() {
         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));
     }
 
-
+    float Radius;
-private:
+    float Height;
+    int Axis;
     AffineTransform m_LocalT;
 };
 

src/Math/Geometry.h

@@ -35,21 +35,10 @@
 
 namespace uLib {
 
-
+class Geometry : public AffineTransform, public Object {
-class Geometry : virtual public Object {
-protected:
-    Geometry* m_Parent = nullptr;
-
 public:
-    uLibTypeMacro(Geometry, Object)
 
-    
+    virtual const char * GetClassName() const { return "Geometry"; }
-
-    virtual void SetParent(Geometry* p) { m_Parent = p; }
-    virtual Geometry* GetParent() const { return m_Parent; }
-
-    virtual bool IsLinear() const { return false; }
-    virtual bool IsPure() const { return false; }
 
     virtual Vector3f ToLinear(const Vector3f& curved_space) const {
         return curved_space;
@@ -59,120 +48,37 @@ public:
         return cartesian_space;
     }
 
-    virtual Vector4f GetWorldPoint(const Vector4f v) const = 0;
+    inline Vector4f GetWorldPoint(const Vector4f v) const {
-    virtual Vector4f GetLocalPoint(const Vector4f v) const = 0;
+        Vector3f lin = ToLinear(Vector3f(v.x(), v.y(), v.z()));
-
+        return this->GetWorldMatrix() * Vector4f(lin.x(), lin.y(), lin.z(), v.w());
-    virtual Vector4f GetWorldPoint(const float x, const float y, const float z) const {
-        return GetWorldPoint(Vector4f(x,y,z,1));
     }
 
-    virtual Vector4f GetLocalPoint(const float x, const float y, const float z) const {
+    inline Vector4f GetWorldPoint(const float x, const float y, const float z) {
-        return GetLocalPoint(Vector4f(x,y,z,1));
+        return this->GetWorldPoint(Vector4f(x,y,z,1));
     }
 
-    virtual Vector4f GetWorldPoint(const Vector3f v) const {
+    inline Vector4f GetLocalPoint(const Vector4f v) const {
-        return GetWorldPoint(Vector4f(v.x(), v.y(), v.z(), 1.0f));
+        Vector4f loc_lin = this->GetWorldMatrix().inverse() * v;
+        Vector3f curv = FromLinear(Vector3f(loc_lin.x(), loc_lin.y(), loc_lin.z()));
+        return Vector4f(curv.x(), curv.y(), curv.z(), loc_lin.w());
     }
 
-    virtual Vector4f GetLocalPoint(const Vector3f v) const {
+    inline Vector4f GetLocalPoint(const float x, const float y, const float z) {
-        return GetLocalPoint(Vector4f(v.x(), v.y(), v.z(), 1.0f));
+         return this->GetLocalPoint(Vector4f(x,y,z,1));
     }
-
-    virtual void Translate(Vector3f t) = 0;
-    virtual void Rotate(Vector3f r) = 0;
-    virtual void Scale(Vector3f s) = 0;
-
 };
 
-
+class CylindricalGeometry : public Geometry {
-
-class LinearGeometry : public Geometry {
-protected:
-    Affine3f m_T = Affine3f::Identity();
-
 public:
-    uLibTypeMacro(LinearGeometry, Geometry)
-
-    
-
-    virtual bool IsLinear() const override { return true; }
-    virtual bool IsPure() const override { return true; }
-
-    virtual Vector4f GetWorldPoint(const Vector4f v) const override {
-        Vector3f lin_v = ToLinear(v.head<3>());
-        Vector4f v_lin(lin_v.x(), lin_v.y(), lin_v.z(), v.w());
-
-        Affine3f combined = m_T;
-        const Geometry* curr = m_Parent;
-        while (curr && curr->IsLinear() && curr->IsPure()) {
-            combined = static_cast<const LinearGeometry*>(curr)->m_T * combined;
-            curr = curr->GetParent();
-        }
-
-        Vector4f v_res = combined.matrix() * v_lin;
-        if (curr) return curr->GetWorldPoint(v_res);
-        return v_res;
-    }
-
-    virtual Vector4f GetLocalPoint(const Vector4f v) const override {
-        Vector4f v_parent = m_Parent ? m_Parent->GetLocalPoint(v) : v;
-        Vector4f v_loc_lin = m_T.inverse().matrix() * v_parent;
-        Vector3f v_curv = FromLinear(v_loc_lin.head<3>());
-        return Vector4f(v_curv.x(), v_curv.y(), v_curv.z(), v_loc_lin.w());
-    }
-
-    virtual void Translate(Vector3f t) override {
-        m_T.translate(t);
-    }
-
-    virtual void Rotate(Vector3f r) override {
-        this->EulerYZYRotate(r);
-    }
-
-    virtual void Scale(Vector3f s) override {
-        m_T.scale(s);
-    }
-
-    void SetPosition(const Vector3f& v) { m_T.translation() = v; }
-    Vector3f GetPosition() const { return m_T.translation(); }
-
-    void EulerYZYRotate(const Vector3f& e) {
-        Matrix3f mat;
-        mat =     Eigen::AngleAxisf(e.x(), Vector3f::UnitY())
-                * Eigen::AngleAxisf(e.y(), Vector3f::UnitZ())
-                * Eigen::AngleAxisf(e.z(), Vector3f::UnitY());
-        m_T.rotate(mat);
-    }
-
-    void FlipAxes(int first, int second) {
-        Matrix3f mat = Matrix3f::Identity();
-        mat.col(first).swap(mat.col(second));
-        m_T.rotate(mat);
-    }
-
-    const Affine3f& GetTransform() const { return m_T; }
-    void SetTransform(const Affine3f& t) { m_T = t; }
-};
-
-
-
-
-class CylindricalGeometry : public LinearGeometry {
-public:
-    uLibTypeMacro(CylindricalGeometry, LinearGeometry)
     CylindricalGeometry() {}
 
-    
+    Vector3f ToLinear(const Vector3f& cylindrical) const {
-
-    virtual bool IsPure() const override { return false; }
-
-    Vector3f ToLinear(const Vector3f& cylindrical) const override {
         return Vector3f(cylindrical.x() * std::cos(cylindrical.y()), 
                         cylindrical.x() * std::sin(cylindrical.y()), 
                         cylindrical.z());
     }
 
-    Vector3f FromLinear(const Vector3f& linear) const override {
+    Vector3f FromLinear(const Vector3f& linear) const {
         float r = std::sqrt(linear.x() * linear.x() + linear.y() * linear.y());
         float phi = std::atan2(linear.y(), linear.x());
         return Vector3f(r, phi, linear.z());
@@ -180,16 +86,13 @@ public:
 
 };
 
-class SphericalGeometry : public LinearGeometry {
+class SphericalGeometry : public Geometry {
 public:
-    uLibTypeMacro(SphericalGeometry, LinearGeometry)
     SphericalGeometry() {}
 
+    virtual const char * GetClassName() const { return "SphericalGeometry"; }
 
-
+    Vector3f ToLinear(const Vector3f& spherical) const {
-    virtual bool IsPure() const override { return false; }
-
-    Vector3f ToLinear(const Vector3f& spherical) const override {
         float r = spherical.x();
         float theta = spherical.y();
         float phi = spherical.z();
@@ -198,7 +101,7 @@ public:
                         r * std::cos(theta));
     }
 
-    Vector3f FromLinear(const Vector3f& linear) const override {
+    Vector3f FromLinear(const Vector3f& linear) const {
         float r = linear.norm();
         float theta = (r == 0.0f) ? 0.0f : std::acos(linear.z() / r);
         float phi = std::atan2(linear.y(), linear.x());
@@ -207,16 +110,13 @@ public:
 
 };
 
-class ToroidalGeometry : public LinearGeometry {
+class ToroidalGeometry : public Geometry {
 public:
-    uLibTypeMacro(ToroidalGeometry, LinearGeometry)
     ToroidalGeometry(float Rtor) : m_Rtor(Rtor) {}
 
+    virtual const char * GetClassName() const { return "ToroidalGeometry"; }
 
-
+    Vector3f ToLinear(const Vector3f& toroidal) const {
-    virtual bool IsPure() const override { return false; }
-
-    Vector3f ToLinear(const Vector3f& toroidal) const override {
         float r = toroidal.x();
         float theta = toroidal.y();
         float phi = toroidal.z();
@@ -225,7 +125,7 @@ public:
                         r * std::sin(theta));
     }
 
-    Vector3f FromLinear(const Vector3f& linear) const override {
+    Vector3f FromLinear(const Vector3f& linear) const {
         float phi = std::atan2(linear.y(), linear.x());
         float r_xy = std::sqrt(linear.x() * linear.x() + linear.y() * linear.y());
         float delta_r = r_xy - m_Rtor;

src/Math/Makefile.am

@@ -0,0 +1,42 @@
+SUBDIRS = .
+
+include $(top_srcdir)/Common.am
+
+library_includedir = $(includedir)/libmutom-${PACKAGE_VERSION}/Math
+library_include_HEADERS = 	ContainerBox.h	\
+				Dense.h 	\
+				Geometry.h	\
+				Transform.h     \
+				StructuredData.h\
+				StructuredGrid.h\
+				VoxImage.h	\
+				VoxRaytracer.h  \
+				Utils.h		\
+				VoxImageFilter.h\
+				VoxImageFilter.hpp \
+				VoxImageFilterLinear.hpp \
+				VoxImageFilterMedian.hpp \
+				VoxImageFilterABTrim.hpp \
+				VoxImageFilterBilateral.hpp \
+				VoxImageFilterThreshold.hpp \
+				VoxImageFilter2ndStat.hpp \
+				VoxImageFilterCustom.hpp \
+                                Accumulator.h \
+				TriangleMesh.h
+
+
+_MATH_SOURCES = \
+                VoxRaytracer.cpp   \
+                StructuredData.cpp \
+                StructuredGrid.cpp \
+                VoxImage.cpp       \
+                TriangleMesh.cpp   \
+		Dense.cpp
+
+
+
+
+noinst_LTLIBRARIES = libmutommath.la
+libmutommath_la_SOURCES = ${_MATH_SOURCES}
+
+

src/Math/MathRegistrations.cpp

@@ -5,15 +5,12 @@
 #include "Math/TriangleMesh.h"
 #include "Math/QuadMesh.h"
 #include "Math/VoxImage.h"
-#include "Math/Assembly.h"
 #include "Math/StructuredData.h"
 
 namespace uLib {
 
-ULIB_REGISTER_OBJECT(TRS)
 ULIB_REGISTER_OBJECT(ContainerBox)
 ULIB_REGISTER_OBJECT(Cylinder)
-ULIB_REGISTER_OBJECT(Assembly)
 ULIB_REGISTER_OBJECT(CylindricalGeometry)
 ULIB_REGISTER_OBJECT(SphericalGeometry)
 ULIB_REGISTER_OBJECT(TriangleMesh)

src/Math/Polydata.h

@@ -36,7 +36,7 @@ class Polydata : public Object {
 
 public:
 
-    
+    virtual const char * GetClassName() const { return "Polydata"; }
 
 
 

src/Math/QuadMesh.h

@@ -34,12 +34,11 @@
 
 namespace uLib {
 
-class QuadMesh : public TRS
+class QuadMesh : public AffineTransform, public Object
 {
 public:
-    uLibTypeMacro(QuadMesh, TRS)
-
 
+    virtual const char * GetClassName() const { return "QuadMesh"; }
 
     void PrintSelf(std::ostream &o);
 

src/Math/Transform.h

@@ -50,49 +50,27 @@
 #define U_TRANSFORM_H
 
 #include <Eigen/Geometry>
-#include "Math/Units.h"
 #include "Math/Dense.h"
 
 
 namespace uLib {
 
-
-
-using Eigen::Isometry3f;
-using Eigen::Isometry3d;
-
-using Eigen::Affine3f;
-using Eigen::Affine3d;
-
-using Eigen::Projective3f;
-using Eigen::Projective3d;
-
-
-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 /////////  AFFINE TRANSFORM  WRAPPER  //////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
+class AffineTransform {
-
-class AffineTransform : virtual public Object {
-public:
-    uLibTypeMacro(AffineTransform, Object)
 protected:
-
+    Eigen::Affine3f  m_T;
-    Affine3f  m_T;
     AffineTransform *m_Parent;
-
 public:
     AffineTransform() :
         m_T(Matrix4f::Identity()),
         m_Parent(NULL)
     {}
 
+    virtual ~AffineTransform() {}
+
     AffineTransform(AffineTransform *parent) :
         m_T(Matrix4f::Identity()),
         m_Parent(parent)
@@ -103,15 +81,14 @@ public:
         m_Parent(copy.m_Parent)
     {}
 
-    Affine3f& GetTransform() { return m_T; }
+    Eigen::Affine3f& GetTransform() { return m_T; }
 
     AffineTransform *GetParent() const { return this->m_Parent; }
 
     void SetParent(AffineTransform *name) { this->m_Parent = name; }
 
-    void SetMatrix (const Matrix4f &mat) { m_T.matrix() = mat; }
+    void SetMatrix (Matrix4f mat) { m_T.matrix() = mat; }
-    Matrix4f& GetMatrix () { return m_T.matrix(); }
+    Matrix4f GetMatrix() const { return m_T.matrix(); }
-    const Matrix4f& GetMatrix () const { return m_T.matrix(); }
 
     Matrix4f GetWorldMatrix() const
     {
@@ -119,32 +96,26 @@ public:
         else return  m_Parent->GetWorldMatrix() * m_T.matrix(); // T = B * A //
     }
 
-    void SetWorldMatrix(const Matrix4f &mat)
+    void SetPosition(const Vector3f v) { this->m_T.translation() = v; }
-    {
-        if(!m_Parent) m_T.matrix() = mat;
-        else m_T.matrix() = m_Parent->GetWorldMatrix().inverse() * mat;
-    }
-
-    void SetPosition(const Vector3f &v) { this->m_T.translation() = v; }
 
     Vector3f GetPosition() const { return this->m_T.translation(); }
 
-    void SetRotation(const Matrix3f &m) { this->m_T.linear() = m; }
+    void SetRotation(const Matrix3f m) { this->m_T.linear() = m; }
 
     Matrix3f GetRotation() const { return this->m_T.rotation(); }
 
-    void Translate(const Vector3f &v) { this->m_T.translate(v); }
+    void Translate(const Vector3f v) { this->m_T.translate(v); }
 
-    void Scale(const Vector3f &v) { this->m_T.scale(v); }
+    void Scale(const Vector3f v) { this->m_T.scale(v); }
 
     Vector3f GetScale() const { 
-        return Vector3f(this->m_T.linear().col(0).norm(),
+        return Vector3f(m_T.linear().col(0).norm(), 
-                        this->m_T.linear().col(1).norm(),
+                        m_T.linear().col(1).norm(), 
-                        this->m_T.linear().col(2).norm());
+                        m_T.linear().col(2).norm()); 
     }
 
 
-    void Rotate(const Matrix3f &m) { this->m_T.rotate(m); }
+    void Rotate(const Matrix3f m) { this->m_T.rotate(m); }
 
     void Rotate(const float angle, Vector3f axis)
     {
@@ -158,12 +129,12 @@ public:
         Rotate(angle,euler_axis);
     }
 
-    void PreRotate(const Matrix3f &m) { this->m_T.prerotate(m); }
+    void PreRotate(const Matrix3f m) { this->m_T.prerotate(m); }
 
-    void QuaternionRotate(const Vector4f &q)
+    void QuaternionRotate(const Vector4f q)
     { this->m_T.rotate(Eigen::Quaternion<float>(q)); }
 
-    void EulerYZYRotate(const Vector3f &e) {
+    void EulerYZYRotate(const Vector3f e) {
         Matrix3f mat;
         mat =     Eigen::AngleAxisf(e.x(), Vector3f::UnitY())
                 * Eigen::AngleAxisf(e.y(), Vector3f::UnitZ())
@@ -181,124 +152,8 @@ public:
 
 
 
-////////////////////////////////////////////////////////////////////////////////
-/////////  TRS PARAMETERS  /////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-typedef Eigen::Affine3f AffineMatrix;
-
-class TRS : public AffineTransform {
-
-    uLibTypeMacro(TRS, AffineTransform)
-    ULIB_SERIALIZE_ACCESS
-    // ULIB_DECLARE_PROPERTIES(TRS)
-
-public:
-
-    Vector3f position = Vector3f::Zero();
-    Vector3f rotation = Vector3f::Zero();
-    Vector3f scaling  = Vector3f::Ones();
-
-    TRS() = default;
-
-    TRS(const class AffineTransform& at) {
-        this->FromMatrix(at.GetMatrix());
-    }
-
-    TRS(const Matrix4f& mat) {
-        this->FromMatrix(mat);
-    }
-
-    void FromMatrix(const Matrix4f& mat) {
-        this->position = mat.block<3,1>(0,3);
-        
-        Matrix3f linear = mat.block<3,3>(0,0);
-        this->scaling(0) = linear.col(0).norm();
-        this->scaling(1) = linear.col(1).norm();
-        this->scaling(2) = linear.col(2).norm();
-        
-        Matrix3f rot = linear;
-        if (this->scaling(0) > 1e-6) rot.col(0) /= this->scaling(0);
-        if (this->scaling(1) > 1e-6) rot.col(1) /= this->scaling(1);
-        if (this->scaling(2) > 1e-6) rot.col(2) /= this->scaling(2);
-        
-        Vector3f euler = rot.eulerAngles(2, 1, 0); 
-        this->rotation = Vector3f(euler(2), euler(1), euler(0));
-        
-        this->SetMatrix(mat);
-        this->NotifyPropertiesUpdated();
-    }
-
-    void SetPosition(const Vector3f &v) { 
-        position = v; 
-        this->AffineTransform::SetPosition(v); 
-    }
-    
-    void SetRotation(const Vector3f &v) { 
-        rotation = v; 
-        this->SyncMatrix(); 
-    }
-    
-    void SetOrientation(const Vector3f &v) { SetRotation(v); }
-    
-    void SetScale(const Vector3f &v) { 
-        scaling = v; 
-        this->SyncMatrix(); 
-    }
-
-    void SyncMatrix() {
-        this->GetTransform() = GetAffineMatrix();
-    }
-
-    void Updated() override {
-        this->SyncMatrix();
-        this->NotifyPropertiesUpdated();
-        this->AffineTransform::Updated();
-    }
-
-    template <class ArchiveT>
-    void serialize(ArchiveT & ar, const unsigned int version) {
-        ar & HRPU(position, "mm");
-        ar & HRPU(rotation, "rad"); 
-        ar & HRP(scaling);
-    }
-    
-
-    AffineMatrix GetAffineMatrix() const {
-        AffineMatrix m = AffineMatrix::Identity();
-        m.translate(position);
-        m.rotate(Eigen::AngleAxisf(rotation.z(), Vector3f::UnitZ()));
-        m.rotate(Eigen::AngleAxisf(rotation.y(), Vector3f::UnitY()));
-        m.rotate(Eigen::AngleAxisf(rotation.x(), Vector3f::UnitX()));
-        m.scale(scaling);
-        return m;
-    }
-
-    Matrix4f GetMatrix() const {
-        return this->GetAffineMatrix().matrix();
-    }
-
-
-    
-    
-};
-
-
-
-
-
-inline std::ostream& operator<<(std::ostream& os, const TRS& trs) {
-    os << trs.position << " " << trs.rotation << " " << trs.scaling;
-    return os;
 }
 
-inline std::istream& operator>>(std::istream& is, TRS& trs) {
-    is >> trs.position >> trs.rotation >> trs.scaling;
-    return is;
-}
-
-} // uLib
-
 
 
 #endif//U_TRANSFORM_H

src/Math/TriangleMesh.h

@@ -37,12 +37,11 @@
 
 namespace uLib {
 
-class TriangleMesh : public TRS
+class TriangleMesh : public AffineTransform, public Object
 {
 public:
-    uLibTypeMacro(TriangleMesh, TRS)
-
 
+    virtual const char * GetClassName() const { return "TriangleMesh"; }
 
     void PrintSelf(std::ostream &o);
 

src/Math/VoxImage.h

@@ -47,7 +47,7 @@ namespace Abstract {
 class VoxImage : public uLib::StructuredGrid {
 public:
 
-  
+  virtual const char * GetClassName() const { return "VoxImage"; }
 
   typedef uLib::StructuredGrid BaseClass;
 

src/Math/VoxImageFilter.h

@@ -27,12 +27,16 @@
 #define VOXIMAGEFILTER_H
 
 #include "Core/StaticInterface.h"
+#include "Core/Algorithm.h"
 #include "Math/Dense.h"
 
 #include "Math/VoxImage.h"
 
 namespace uLib {
 
+////////////////////////////////////////////////////////////////////////////////
+// Kernel shape interface (static check for operator()(float) and operator()(Vector3f))
+
 namespace Interface {
 struct VoxImageFilterShape {
   template <class Self> void check_structural() {
@@ -42,63 +46,95 @@ struct VoxImageFilterShape {
 };
 } // namespace Interface
 
+////////////////////////////////////////////////////////////////////////////////
+// Forward declaration
+
 template <typename VoxelT> class Kernel;
 
+////////////////////////////////////////////////////////////////////////////////
+// Abstract interface (type-erased, used by python bindings)
+
 namespace Abstract {
 class VoxImageFilter {
 public:
   virtual void Run() = 0;
-
   virtual void SetImage(Abstract::VoxImage *image) = 0;
-
 protected:
   virtual ~VoxImageFilter() {}
 };
 } // namespace Abstract
 
-template <typename VoxelT, typename AlgorithmT>
+////////////////////////////////////////////////////////////////////////////////
-class VoxImageFilter : public Abstract::VoxImageFilter, public Object {
+// VoxImageFilter — kernel-based voxel filter using CRTP + Algorithm
+//
+// Template parameters:
+//   VoxelT     — voxel data type (must satisfy Interface::Voxel)
+//   CrtpImplT  — concrete filter subclass (CRTP), must provide:
+//                 float Evaluate(const VoxImage<VoxelT>& buffer, int index)
+//
+// Inherits Algorithm<VoxImage<VoxelT>*, VoxImage<VoxelT>*> so that filters
+// can be used with AlgorithmTask for scheduled/async execution, and chained
+// via encoder/decoder.
 
+template <typename VoxelT, typename CrtpImplT>
+class VoxImageFilter : public Abstract::VoxImageFilter,
+                       public Algorithm<VoxImage<VoxelT>*, VoxImage<VoxelT>*> {
 public:
 
-  
+  virtual const char* GetClassName() const { return "VoxImageFilter"; }
 
   VoxImageFilter(const Vector3i &size);
 
+  // Algorithm interface ////////////////////////////////////////////////////////
+
+  /**
+   * @brief Process implements Algorithm::Process.
+   * Applies the filter in-place on the input image and returns it.
+   */
+  VoxImage<VoxelT>* Process(VoxImage<VoxelT>* const& image) override;
+
+  /**
+   * @brief Run implements Abstract::VoxImageFilter::Run.
+   * Calls Process on the current image.
+   */
   void Run();
 
+  // Device awareness ///////////////////////////////////////////////////////////
+
+  /** @brief Returns VRAM if image or kernel data is on GPU, RAM otherwise. */
+  MemoryDevice GetPreferredDevice() const override {
+    if (m_Image && m_Image->Data().GetDevice() == MemoryDevice::VRAM)
+      return MemoryDevice::VRAM;
+    if (m_KernelData.ConstData().GetDevice() == MemoryDevice::VRAM)
+      return MemoryDevice::VRAM;
+    return MemoryDevice::RAM;
+  }
+
+  // Kernel setup ///////////////////////////////////////////////////////////////
+
   void SetKernelNumericXZY(const std::vector<float> &numeric);
-
   void SetKernelSpherical(float (*shape)(float));
-
   template <class ShapeT> void SetKernelSpherical(ShapeT shape);
-
   void SetKernelWeightFunction(float (*shape)(const Vector3f &));
-
   template <class ShapeT> void SetKernelWeightFunction(ShapeT shape);
 
-  inline const Kernel<VoxelT> &GetKernelData() const {
+  // Accessors //////////////////////////////////////////////////////////////////
-    return this->m_KernelData;
-  }
-  inline Kernel<VoxelT> &GetKernelData() { return this->m_KernelData; }
 
-  inline VoxImage<VoxelT> *GetImage() const { return this->m_Image; }
+  const Kernel<VoxelT> &GetKernelData() const { return m_KernelData; }
+  Kernel<VoxelT> &GetKernelData() { return m_KernelData; }
 
+  VoxImage<VoxelT> *GetImage() const { return m_Image; }
   void SetImage(Abstract::VoxImage *image);
 
 protected:
-  float Convolve(const VoxImage<VoxelT> &buffer, int index); // remove //
-
   void SetKernelOffset();
-
   float Distance2(const Vector3i &v);
 
-  // protected members for algorithm access //
   Kernel<VoxelT> m_KernelData;
   VoxImage<VoxelT> *m_Image;
 
 private:
-  AlgorithmT *t_Algoritm;
+  CrtpImplT *m_CrtpImpl;
 };
 
 } // namespace uLib

src/Math/VoxImageFilter.hpp

@@ -33,7 +33,9 @@
 
 namespace uLib {
 
-// KERNEL //////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//// KERNEL ////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 template <typename T> class Kernel : public StructuredData {
   typedef StructuredData BaseClass;
@@ -41,13 +43,12 @@ template <typename T> class Kernel : public StructuredData {
 public:
   Kernel(const Vector3i &size);
 
-  inline T &operator[](const Vector3i &id) { return m_Data[Map(id)]; }
+  T &operator[](const Vector3i &id) { return m_Data[Map(id)]; }
-  inline T &operator[](const int &id) { return m_Data[id]; }
+  T &operator[](const int &id) { return m_Data[id]; }
-  inline int GetCenterData() const;
+  int GetCenterData() const;
 
-  inline DataAllocator<T> &Data() { return this->m_Data; }
+  DataAllocator<T> &Data() { return m_Data; }
-
+  const DataAllocator<T> &ConstData() const { return m_Data; }
-  inline const DataAllocator<T> &ConstData() const { return this->m_Data; }
 
   void PrintSelf(std::ostream &o) const;
 
@@ -60,12 +61,14 @@ Kernel<T>::Kernel(const Vector3i &size) : BaseClass(size), m_Data(size.prod()) {
   Interface::IsA<T, Interface::Voxel>();
 }
 
-template <typename T> inline int Kernel<T>::GetCenterData() const {
+template <typename T>
+int Kernel<T>::GetCenterData() const {
   static int center = Map(this->GetDims() / 2);
   return center;
 }
 
-template <typename T> void Kernel<T>::PrintSelf(std::ostream &o) const {
+template <typename T>
+void Kernel<T>::PrintSelf(std::ostream &o) const {
   o << " Filter Kernel Dump [XZ_Y]: \n";
   Vector3i index;
   o << "\n Value: \n\n"
@@ -96,25 +99,42 @@ template <typename T> void Kernel<T>::PrintSelf(std::ostream &o) const {
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+//// VOXIMAGEFILTER IMPLEMENTATION /////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
+template <typename VoxelT, typename CrtpImplT>
+VoxImageFilter<VoxelT, CrtpImplT>::VoxImageFilter(const Vector3i &size)
+    : m_KernelData(size)
+    , m_Image(nullptr)
+    , m_CrtpImpl(static_cast<CrtpImplT *>(this))
+{}
 
-
+template <typename VoxelT, typename CrtpImplT>
-template <typename VoxelT, typename AlgorithmT>
+VoxImage<VoxelT>* VoxImageFilter<VoxelT, CrtpImplT>::Process(
-VoxImageFilter<VoxelT, AlgorithmT>::VoxImageFilter(const Vector3i &size)
+    VoxImage<VoxelT>* const& image) {
-    : m_KernelData(size), t_Algoritm(static_cast<AlgorithmT *>(this)) {}
+  if (m_Image != image) SetImage(image);
-
-template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<VoxelT, AlgorithmT>::Run() {
   VoxImage<VoxelT> buffer = *m_Image;
 #pragma omp parallel for
   for (int i = 0; i < m_Image->Data().size(); ++i)
-    m_Image->operator[](i).Value = this->t_Algoritm->Evaluate(buffer, i);
+    m_Image->operator[](i).Value = m_CrtpImpl->Evaluate(buffer, i);
 #pragma omp barrier
+  return m_Image;
 }
 
-template <typename VoxelT, typename AlgorithmT>
+template <typename VoxelT, typename CrtpImplT>
-void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelOffset() {
+void VoxImageFilter<VoxelT, CrtpImplT>::Run() {
+  Process(m_Image);
+}
+
+template <typename VoxelT, typename CrtpImplT>
+void VoxImageFilter<VoxelT, CrtpImplT>::SetImage(Abstract::VoxImage *image) {
+  m_Image = reinterpret_cast<VoxImage<VoxelT> *>(image);
+  SetKernelOffset();
+}
+
+template <typename VoxelT, typename CrtpImplT>
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelOffset() {
   Vector3i id(0, 0, 0);
   for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
     for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
@@ -126,10 +146,10 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelOffset() {
   }
 }
 
-template <typename VoxelT, typename AlgorithmT>
+template <typename VoxelT, typename CrtpImplT>
-float VoxImageFilter<VoxelT, AlgorithmT>::Distance2(const Vector3i &v) {
+float VoxImageFilter<VoxelT, CrtpImplT>::Distance2(const Vector3i &v) {
   Vector3i tmp = v;
-  const Vector3i &dim = this->m_KernelData.GetDims();
+  const Vector3i &dim = m_KernelData.GetDims();
   Vector3i center = dim / 2;
   tmp = tmp - center;
   center = center.cwiseProduct(center);
@@ -139,12 +159,9 @@ float VoxImageFilter<VoxelT, AlgorithmT>::Distance2(const Vector3i &v) {
                  0.25 * (3 - (dim(0) % 2) - (dim(1) % 2) - (dim(2) % 2)));
 }
 
-template <typename VoxelT, typename AlgorithmT>
+template <typename VoxelT, typename CrtpImplT>
-void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelNumericXZY(
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelNumericXZY(
     const std::vector<float> &numeric) {
-  // set data order //
-  StructuredData::Order order = m_KernelData.GetDataOrder();
-  // m_KernelData.SetDataOrder(StructuredData::XZY);
   Vector3i id;
   int index = 0;
   for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
@@ -155,38 +172,39 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelNumericXZY(
       }
     }
   }
-  // m_KernelData.SetDataOrder(order);
 }
 
-template <typename VoxelT, typename AlgorithmT>
+template <typename VoxelT, typename CrtpImplT>
-void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelSpherical(float (*shape)(float)) {
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelSpherical(
+    float (*shape)(float)) {
   Vector3i id;
   for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
     for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
       for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
         id << x, y, z;
-        m_KernelData[id].Value = shape(this->Distance2(id));
+        m_KernelData[id].Value = shape(Distance2(id));
       }
     }
   }
 }
 
-template <typename VoxelT, typename AlgorithmT> template <class ShapeT>
+template <typename VoxelT, typename CrtpImplT>
-void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelSpherical(ShapeT shape) {
+template <class ShapeT>
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelSpherical(ShapeT shape) {
   Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
   Vector3i id;
   for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
     for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
       for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
         id << x, y, z;
-        m_KernelData[id].Value = shape(this->Distance2(id));
+        m_KernelData[id].Value = shape(Distance2(id));
       }
     }
   }
 }
 
-template <typename VoxelT, typename AlgorithmT>
+template <typename VoxelT, typename CrtpImplT>
-void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelWeightFunction(
     float (*shape)(const Vector3f &)) {
   const Vector3i &dim = m_KernelData.GetDims();
   Vector3i id;
@@ -194,20 +212,19 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(
   for (int y = 0; y < dim(1); ++y) {
     for (int z = 0; z < dim(2); ++z) {
       for (int x = 0; x < dim(0); ++x) {
-        // get voxels centroid coords from kernel center //
         id << x, y, z;
         pt << id(0) - dim(0) / 2 + 0.5 * !(dim(0) % 2),
             id(1) - dim(1) / 2 + 0.5 * !(dim(1) % 2),
             id(2) - dim(2) / 2 + 0.5 * !(dim(2) % 2);
-        // compute function using given shape //
         m_KernelData[id].Value = shape(pt);
       }
     }
   }
 }
 
-template <typename VoxelT, typename AlgorithmT> template <class ShapeT>
+template <typename VoxelT, typename CrtpImplT>
-void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(ShapeT shape) {
+template <class ShapeT>
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelWeightFunction(ShapeT shape) {
   Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
   const Vector3i &dim = m_KernelData.GetDims();
   Vector3i id;
@@ -215,45 +232,16 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(ShapeT shape) {
   for (int y = 0; y < dim(1); ++y) {
     for (int z = 0; z < dim(2); ++z) {
       for (int x = 0; x < dim(0); ++x) {
-        // get voxels centroid coords from kernel center //
         id << x, y, z;
         pt << id(0) - dim(0) / 2 + 0.5 * !(dim(0) % 2),
             id(1) - dim(1) / 2 + 0.5 * !(dim(1) % 2),
             id(2) - dim(2) / 2 + 0.5 * !(dim(2) % 2);
-        // compute function using given shape //
         m_KernelData[id].Value = shape(pt);
       }
     }
   }
 }
 
-template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<VoxelT, AlgorithmT>::SetImage(Abstract::VoxImage *image) {
-  this->m_Image = reinterpret_cast<VoxImage<VoxelT> *>(image);
-  this->SetKernelOffset();
-}
-
-template <typename VoxelT, typename AlgorithmT>
-float VoxImageFilter<VoxelT, AlgorithmT>::Convolve(const VoxImage<VoxelT> &buffer,
-                                       int index) {
-  const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
-  const DataAllocator<VoxelT> &vker = m_KernelData.ConstData();
-  int vox_size = vbuf.size();
-  int ker_size = vker.size();
-  int pos;
-  float conv = 0, ksum = 0;
-  for (int ik = 0; ik < ker_size; ++ik) {
-    pos = index + vker[ik].Count - vker[m_KernelData.GetCenterData()].Count;
-    pos = (pos + vox_size) % vox_size;
-    conv += vbuf[pos].Value * vker[ik].Value;
-    ksum += vker[ik].Value;
-  }
-  return conv / ksum;
-}
-
-
-
-
 } // namespace uLib
 
 #endif // VOXIMAGEFILTER_HPP

src/Math/VoxImageFilterABTrim.hpp

@@ -109,7 +109,8 @@ public:
   }
 
 #if defined(USE_CUDA) && defined(__CUDACC__)
-  void Run() {
+  VoxImage<VoxelT>* Process(VoxImage<VoxelT>* const& image) override {
+    if (this->m_Image != image) this->SetImage(image);
     if (this->m_Image->Data().GetDevice() == MemoryDevice::VRAM ||
         this->m_KernelData.Data().GetDevice() == MemoryDevice::VRAM) {
 
@@ -136,8 +137,9 @@ public:
           d_img_in, d_img_out, d_kernel, vox_size, ker_size, center_count,
           mAtrim, mBtrim);
       cudaDeviceSynchronize();
+      return this->m_Image;
     } else {
-      BaseClass::Run();
+      return BaseClass::Process(image);
     }
   }
 #endif
@@ -207,7 +209,8 @@ public:
   }
 
 #if defined(USE_CUDA) && defined(__CUDACC__)
-  void Run() {
+  VoxImage<VoxelT>* Process(VoxImage<VoxelT>* const& image) override {
+    if (this->m_Image != image) this->SetImage(image);
     if (this->m_Image->Data().GetDevice() == MemoryDevice::VRAM ||
         this->m_KernelData.Data().GetDevice() == MemoryDevice::VRAM) {
 
@@ -234,8 +237,9 @@ public:
           d_img_in, d_img_out, d_kernel, vox_size, ker_size, center_count,
           mAtrim, mBtrim);
       cudaDeviceSynchronize();
+      return this->m_Image;
     } else {
-      BaseClass::Run();
+      return BaseClass::Process(image);
     }
   }
 #endif

src/Math/VoxImageFilterCustom.hpp

@@ -30,8 +30,6 @@
 #include "VoxImageFilter.h"
 #include <Math/Dense.h>
 
-#define likely(expr) __builtin_expect(!!(expr), 1)
-
 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER CUSTOM  /////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -50,7 +48,7 @@ public:
       : BaseClass(size), m_CustomEvaluate(NULL) {}
 
   float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
-    if (likely(m_CustomEvaluate)) {
+    if (m_CustomEvaluate) {
       const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
       const DataAllocator<VoxelT> &vker = this->m_KernelData.ConstData();
       int vox_size = vbuf.size();

src/Math/VoxImageFilterLinear.hpp

@@ -67,7 +67,8 @@ public:
   VoxFilterAlgorithmLinear(const Vector3i &size) : BaseClass(size) {}
 
 #if defined(USE_CUDA) && defined(__CUDACC__)
-  void Run() {
+  VoxImage<VoxelT>* Process(VoxImage<VoxelT>* const& image) override {
+    if (this->m_Image != image) this->SetImage(image);
     if (this->m_Image->Data().GetDevice() == MemoryDevice::VRAM ||
         this->m_KernelData.Data().GetDevice() == MemoryDevice::VRAM) {
 
@@ -92,8 +93,9 @@ public:
       LinearFilterKernel<<<blocksPerGrid, threadsPerBlock>>>(
           d_img_in, d_img_out, d_kernel, vox_size, ker_size, center_count);
       cudaDeviceSynchronize();
+      return this->m_Image;
     } else {
-      BaseClass::Run();
+      return BaseClass::Process(image);
     }
   }
 #endif

src/Math/VoxImageFilterThreshold.hpp

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef VOXIMAGEFILTERTHRESHOLD_HPP
 #define VOXIMAGEFILTERTHRESHOLD_HPP
 
@@ -39,40 +37,24 @@
 namespace uLib {
 
 template <typename VoxelT>
-class VoxFilterAlgorithmThreshold :
+class VoxFilterAlgorithmThreshold
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT> > {
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT>> {
 
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT> > BaseClass;
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT>> BaseClass;
-    //    ULIB_OBJECT_PARAMETERS(BaseClass) {
-    //        float threshold;
-    //    };
 
   float m_threshold;
 
 public:
-    VoxFilterAlgorithmThreshold(const Vector3i &size) : BaseClass(size)
+  VoxFilterAlgorithmThreshold(const Vector3i &size)
-    {
+      : BaseClass(size), m_threshold(0) {}
-        //        init_parameters();
+
-        m_threshold = 0;
+  void SetThreshold(float th) { m_threshold = th; }
+
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    return static_cast<float>(buffer.ConstData().at(index).Value >= m_threshold);
   }
-
-    inline void SetThreshold(float th) { m_threshold = th; }
-
-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        return static_cast<float>(buffer.ConstData().at(index).Value >=
-                                  //                                  parameters().threshold);
-                                  m_threshold );
-    }
-
 };
 
-//template <typename VoxelT>
+} // namespace uLib
-//inline void VoxFilterAlgorithmThreshold<VoxelT>::init_parameters()
-//{
-//    parameters().threshold = 0;
-//}
-
-}
 
 #endif // VOXIMAGEFILTERTHRESHOLD_HPP

src/Math/testing/AlgorithmCudaChainTest.cpp

@@ -0,0 +1,408 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 "testing-prototype.h"
+
+#include "Core/Algorithm.h"
+#include "Math/VoxImage.h"
+#include "Math/VoxImageFilter.h"
+
+#include <iostream>
+#include <thread>
+#include <chrono>
+
+using namespace uLib;
+
+struct TestVoxel {
+  Scalarf Value;
+  unsigned int Count;
+};
+
+int main() {
+  BEGIN_TESTING(AlgorithmCudaChain);
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 1: Single filter — GetPreferredDevice reflects data location
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 1: GetPreferredDevice reflects data location ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(10, 10, 10));
+    image[Vector3i(5, 5, 5)].Value = 1;
+
+    VoxFilterAlgorithmLinear<TestVoxel> filter(Vector3i(3, 3, 3));
+    std::vector<float> weights(27, 1.0f);
+    filter.SetImage(&image);
+    filter.SetKernelNumericXZY(weights);
+
+    // Before VRAM move: should prefer RAM
+    TEST1(filter.GetPreferredDevice() == MemoryDevice::RAM);
+    TEST1(!filter.IsGPU());
+    std::cout << "  RAM mode: PreferredDevice=RAM, IsGPU=false  OK\n";
+
+    // Move image data to VRAM
+    image.Data().MoveToVRAM();
+
+    // After VRAM move: should prefer VRAM
+    TEST1(filter.GetPreferredDevice() == MemoryDevice::VRAM);
+    TEST1(filter.IsGPU());
+    std::cout << "  VRAM mode: PreferredDevice=VRAM, IsGPU=true  OK\n";
+
+    // Move back to RAM
+    image.Data().MoveToRAM();
+    TEST1(filter.GetPreferredDevice() == MemoryDevice::RAM);
+    std::cout << "  Back to RAM: PreferredDevice=RAM  OK\n";
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 2: Kernel data on VRAM also triggers GPU preference
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 2: Kernel on VRAM triggers GPU preference ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(8, 8, 8));
+    VoxFilterAlgorithmLinear<TestVoxel> filter(Vector3i(3, 3, 3));
+    std::vector<float> weights(27, 1.0f);
+    filter.SetImage(&image);
+    filter.SetKernelNumericXZY(weights);
+
+    TEST1(filter.GetPreferredDevice() == MemoryDevice::RAM);
+
+    // Only kernel on VRAM
+    filter.GetKernelData().Data().MoveToVRAM();
+    TEST1(filter.GetPreferredDevice() == MemoryDevice::VRAM);
+    std::cout << "  Kernel on VRAM: PreferredDevice=VRAM  OK\n";
+
+    filter.GetKernelData().Data().MoveToRAM();
+    TEST1(filter.GetPreferredDevice() == MemoryDevice::RAM);
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 3: Algorithm interface — Process through base pointer
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 3: Process through Algorithm base pointer ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(10, 10, 10));
+    image[Vector3i(5, 5, 5)].Value = 10;
+
+    VoxFilterAlgorithmLinear<TestVoxel> filter(Vector3i(3, 3, 3));
+    std::vector<float> weights(27, 1.0f);
+    filter.SetImage(&image);
+    filter.SetKernelNumericXZY(weights);
+
+    // Use through Algorithm base class pointer
+    Algorithm<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*>* alg = &filter;
+
+    VoxImage<TestVoxel>* result = alg->Process(&image);
+    TEST1(result == &image);
+    std::cout << "  Process through base pointer returned correct image  OK\n";
+
+    // Verify filter actually ran (center voxel should be averaged)
+    // With uniform 3x3x3 kernel and single non-zero voxel at center,
+    // the center value should be 10/27 ≈ 0.37
+    TEST1(image[Vector3i(5, 5, 5)].Value < 10.0f);
+    std::cout << "  Filter modified voxel values  OK\n";
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 4: Encoder/decoder chain — two filters linked
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 4: Encoder/decoder chain ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(10, 10, 10));
+    image[Vector3i(5, 5, 5)].Value = 100;
+
+    // First filter: linear smoothing
+    VoxFilterAlgorithmLinear<TestVoxel> filter1(Vector3i(3, 3, 3));
+    std::vector<float> weights1(27, 1.0f);
+    filter1.SetImage(&image);
+    filter1.SetKernelNumericXZY(weights1);
+
+    // Second filter: threshold
+    VoxFilterAlgorithmThreshold<TestVoxel> filter2(Vector3i(1, 1, 1));
+    filter2.SetThreshold(0.5f);
+    filter2.SetImage(&image);
+    // 1x1x1 kernel with value 1
+    std::vector<float> weights2(1, 1.0f);
+    filter2.SetKernelNumericXZY(weights2);
+
+    // Chain: filter1 → filter2
+    filter1.SetDecoder(&filter2);
+    filter2.SetEncoder(&filter1);
+
+    TEST1(filter1.GetDecoder() == &filter2);
+    TEST1(filter2.GetEncoder() == &filter1);
+    std::cout << "  Chain linked: filter1 -> filter2  OK\n";
+
+    // Execute chain manually (encoder first, then decoder)
+    filter1.Process(&image);
+    float smoothed_center = image[Vector3i(5, 5, 5)].Value;
+    std::cout << "  After linear: center = " << smoothed_center << "\n";
+
+    filter2.Process(&image);
+    float thresholded_center = image[Vector3i(5, 5, 5)].Value;
+    std::cout << "  After threshold: center = " << thresholded_center << "\n";
+
+    // After threshold, values should be 0 or 1
+    TEST1(thresholded_center == 0.0f || thresholded_center == 1.0f);
+    std::cout << "  Chain execution produced valid results  OK\n";
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 5: CUDA chain — VRAM data through chained filters
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 5: VRAM data through chained filters ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(10, 10, 10));
+    image[Vector3i(5, 5, 5)].Value = 50;
+
+    VoxFilterAlgorithmLinear<TestVoxel> filter1(Vector3i(3, 3, 3));
+    std::vector<float> weights1(27, 1.0f);
+    filter1.SetImage(&image);
+    filter1.SetKernelNumericXZY(weights1);
+
+    VoxFilterAlgorithmAbtrim<TestVoxel> filter2(Vector3i(3, 3, 3));
+    std::vector<float> weights2(27, 1.0f);
+    filter2.SetImage(&image);
+    filter2.SetKernelNumericXZY(weights2);
+    filter2.SetABTrim(1, 1);
+
+    // Chain
+    filter1.SetDecoder(&filter2);
+    filter2.SetEncoder(&filter1);
+
+    // Move data to VRAM
+    image.Data().MoveToVRAM();
+    filter1.GetKernelData().Data().MoveToVRAM();
+    filter2.GetKernelData().Data().MoveToVRAM();
+
+    // Both filters should report VRAM preference
+    TEST1(filter1.GetPreferredDevice() == MemoryDevice::VRAM);
+    TEST1(filter2.GetPreferredDevice() == MemoryDevice::VRAM);
+    TEST1(filter1.IsGPU());
+    TEST1(filter2.IsGPU());
+    std::cout << "  Both filters detect VRAM preference  OK\n";
+
+    // Verify the chain's device consistency
+    auto* encoder = filter2.GetEncoder();
+    TEST1(encoder != nullptr);
+    TEST1(encoder->IsGPU());
+    std::cout << "  Encoder in chain also reports GPU  OK\n";
+
+#ifdef USE_CUDA
+    // With CUDA: filters execute on GPU via Process()
+    image.Data().MoveToRAM(); // reset for clean test
+    image[Vector3i(5, 5, 5)].Value = 50;
+    image.Data().MoveToVRAM();
+
+    filter1.Process(&image);
+    TEST1(image.Data().GetDevice() == MemoryDevice::VRAM);
+    std::cout << "  CUDA: data stays in VRAM after filter1  OK\n";
+
+    filter2.Process(&image);
+    TEST1(image.Data().GetDevice() == MemoryDevice::VRAM);
+    std::cout << "  CUDA: data stays in VRAM after filter2  OK\n";
+#else
+    // Without CUDA: verify Process still works via CPU fallback
+    image.Data().MoveToRAM();
+    image[Vector3i(5, 5, 5)].Value = 50;
+
+    filter1.GetKernelData().Data().MoveToRAM();
+    filter2.GetKernelData().Data().MoveToRAM();
+
+    filter1.Process(&image);
+    filter2.Process(&image);
+    std::cout << "  No CUDA: CPU fallback executed correctly  OK\n";
+#endif
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 6: AlgorithmTask with VRAM-aware filter
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 6: AlgorithmTask with VRAM-aware filter ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(8, 8, 8));
+    image[Vector3i(4, 4, 4)].Value = 20;
+
+    VoxFilterAlgorithmLinear<TestVoxel> filter(Vector3i(3, 3, 3));
+    std::vector<float> weights(27, 1.0f);
+    filter.SetImage(&image);
+    filter.SetKernelNumericXZY(weights);
+
+    // Set up task
+    AlgorithmTask<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*> task;
+    task.SetAlgorithm(&filter);
+    task.SetMode(AlgorithmTask<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*>::Cyclic);
+    task.SetCycleTime(50);
+
+    // Run task for a few cycles
+    task.Run(&image);
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    task.Stop();
+
+    // After cyclic execution, the filter should have smoothed values
+    TEST1(image[Vector3i(4, 4, 4)].Value < 20.0f);
+    std::cout << "  Task cyclic execution modified image  OK\n";
+    std::cout << "  Center value after smoothing: "
+              << image[Vector3i(4, 4, 4)].Value << "\n";
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 7: AlgorithmTask async with chained filters
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 7: AlgorithmTask async with filter ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(8, 8, 8));
+    image[Vector3i(4, 4, 4)].Value = 30;
+
+    VoxFilterAlgorithmLinear<TestVoxel> filter(Vector3i(3, 3, 3));
+    std::vector<float> weights(27, 1.0f);
+    filter.SetImage(&image);
+    filter.SetKernelNumericXZY(weights);
+
+    AlgorithmTask<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*> task;
+    task.SetAlgorithm(&filter);
+    task.SetMode(AlgorithmTask<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*>::Async);
+
+    float before = image[Vector3i(4, 4, 4)].Value;
+
+    task.Run(&image);
+
+    // Trigger one execution
+    task.Notify();
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+    task.Stop();
+
+    float after = image[Vector3i(4, 4, 4)].Value;
+    TEST1(after < before);
+    std::cout << "  Async trigger: value " << before << " -> " << after << "  OK\n";
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 8: Device preference propagation in chain
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 8: Device preference propagation check ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(8, 8, 8));
+    image[Vector3i(4, 4, 4)].Value = 10;
+
+    VoxFilterAlgorithmLinear<TestVoxel> filterA(Vector3i(3, 3, 3));
+    VoxFilterAlgorithmAbtrim<TestVoxel> filterB(Vector3i(3, 3, 3));
+    VoxFilterAlgorithmThreshold<TestVoxel> filterC(Vector3i(1, 1, 1));
+
+    std::vector<float> w27(27, 1.0f);
+    std::vector<float> w1(1, 1.0f);
+
+    filterA.SetImage(&image);
+    filterA.SetKernelNumericXZY(w27);
+    filterB.SetImage(&image);
+    filterB.SetKernelNumericXZY(w27);
+    filterB.SetABTrim(1, 1);
+    filterC.SetImage(&image);
+    filterC.SetKernelNumericXZY(w1);
+    filterC.SetThreshold(0.1f);
+
+    // Chain: A → B → C
+    filterA.SetDecoder(&filterB);
+    filterB.SetEncoder(&filterA);
+    filterB.SetDecoder(&filterC);
+    filterC.SetEncoder(&filterB);
+
+    // All on RAM
+    TEST1(!filterA.IsGPU());
+    TEST1(!filterB.IsGPU());
+    TEST1(!filterC.IsGPU());
+    std::cout << "  All filters on RAM  OK\n";
+
+    // Move image to VRAM — filters A and B should detect it
+    image.Data().MoveToVRAM();
+    TEST1(filterA.IsGPU());
+    TEST1(filterB.IsGPU());
+    // filterC with 1x1x1 kernel doesn't have CUDA override, but still detects VRAM
+    TEST1(filterC.IsGPU());
+    std::cout << "  Image on VRAM: all filters report GPU  OK\n";
+
+    // Can walk the chain and check device consistency
+    auto* step = static_cast<Algorithm<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*>*>(&filterA);
+    bool all_gpu = true;
+    while (step) {
+      if (!step->IsGPU()) all_gpu = false;
+      step = static_cast<Algorithm<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*>*>(step->GetDecoder());
+    }
+    TEST1(all_gpu);
+    std::cout << "  Chain walk: all steps report GPU  OK\n";
+
+    image.Data().MoveToRAM();
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // TEST 9: Process through chain with Algorithm interface
+  ////////////////////////////////////////////////////////////////////////////
+  {
+    std::cout << "\n--- Test 9: Sequential chain processing via Algorithm interface ---\n";
+
+    VoxImage<TestVoxel> image(Vector3i(10, 10, 10));
+    // Set a pattern: single bright voxel
+    image[Vector3i(5, 5, 5)].Value = 100;
+
+    VoxFilterAlgorithmLinear<TestVoxel> filterA(Vector3i(3, 3, 3));
+    std::vector<float> w(27, 1.0f);
+    filterA.SetImage(&image);
+    filterA.SetKernelNumericXZY(w);
+
+    VoxFilterAlgorithmLinear<TestVoxel> filterB(Vector3i(3, 3, 3));
+    filterB.SetImage(&image);
+    filterB.SetKernelNumericXZY(w);
+
+    // Chain
+    filterA.SetDecoder(&filterB);
+    filterB.SetEncoder(&filterA);
+
+    // Process chain through base pointer
+    using AlgType = Algorithm<VoxImage<TestVoxel>*, VoxImage<TestVoxel>*>;
+    AlgType* chain = &filterA;
+
+    // Walk and process
+    AlgType* current = chain;
+    while (current) {
+      current->Process(&image);
+      current = static_cast<AlgType*>(current->GetDecoder());
+    }
+
+    // After two rounds of smoothing, the peak should be smaller than original
+    float final_val = image[Vector3i(5, 5, 5)].Value;
+    TEST1(final_val < 100.0f);
+    std::cout << "  Two-stage smoothing: peak = " << final_val << "  OK\n";
+  }
+
+  END_TESTING;
+}

src/Math/testing/CMakeLists.txt

@@ -16,6 +16,7 @@ set(TESTS
         QuadMeshTest
         BitCodeTest
         UnitsTest
+        AlgorithmCudaChainTest
 )
 
 set(LIBRARIES
@@ -28,6 +29,6 @@ set(LIBRARIES
 uLib_add_tests(Math)
 
 if(USE_CUDA)
-    set_source_files_properties(VoxImageTest.cpp VoxImageCopyTest.cpp VoxImageFilterTest.cpp VoxRaytracerTest.cpp VoxRaytracerTestExtended.cpp PROPERTIES LANGUAGE CUDA)
+    set_source_files_properties(VoxImageTest.cpp VoxImageCopyTest.cpp VoxImageFilterTest.cpp VoxRaytracerTest.cpp VoxRaytracerTestExtended.cpp AlgorithmCudaChainTest.cpp PROPERTIES LANGUAGE CUDA)
     set_source_files_properties(VoxRaytracerTest.cpp VoxRaytracerTestExtended.cpp PROPERTIES CXX_STANDARD 17 CUDA_STANDARD 17)
 endif()

src/Math/testing/GeometryTest.cpp

@@ -53,7 +53,7 @@ int main()
   ///////////////// GEOMETRY TESTING ///////////////////////////////////////////
   //////////////////////////////////////////////////////////////////////////////
 
-  LinearGeometry Geo;
+  Geometry Geo;
 
   Geo.SetPosition(Vector3f(1,1,1));
   Geo.EulerYZYRotate(Vector3f(0,0,0));
@@ -77,7 +77,7 @@ int main()
 
   Geo.EulerYZYRotate(Vector3f(0,0,M_PI_2));
   wp = Geo.GetWorldPoint(HPoint3f(1,1,1));
-  //  std::cout << "Geometry matrix\n" << Geo.GetTransform().matrix() << "\n";
+  //  std::cout << "Geometry matrix\n" << Geo.GetTransform() << "\n";
   //  std::cout << "World 1,1,1 coords\n" << wp << "\n";
   TEST0( Vector4f0(wp - HPoint3f(0,2,2)) );
 
@@ -122,27 +122,6 @@ int main()
     TEST0( Vector4f0(recovered.homogeneous() - tor_pt.homogeneous()) );
   }
 
-  // PARENT GEOMETRY TESTING
-  {
-    LinearGeometry parent;
-    parent.Translate(Vector3f(10, 0, 0));
-
-    LinearGeometry child;
-    child.SetParent(&parent);
-    child.Translate(Vector3f(0, 5, 0));
-
-    HPoint3f wp = child.GetWorldPoint(HPoint3f(1, 1, 1));
-    TEST0( Vector4f0(wp - HPoint3f(11, 6, 1)) );
-
-    CylindricalGeometry cparent;
-    LinearGeometry grandchild;
-    grandchild.SetParent(&cparent);
-    grandchild.Translate(Vector3f(1, 0, 0)); 
-
-    HPoint3f gp = grandchild.GetWorldPoint(HPoint3f(1, M_PI_2, 0));
-    TEST0( Vector4f0(gp - HPoint3f(0, 2, 0)) );
-  }
-
   END_TESTING;
 }
 

src/Math/testing/testing-prototype.h

@@ -31,10 +31,8 @@
 static int _fail = 0;                      \
 printf("..:: Testing " #name " ::..\n");
 
-#define TEST1(val) _fail += (val)==0
+#define TEST1(val) if ((val)==0) { printf("Assertion failed: %s != 0\n", #val); _fail++; }
-#define TEST0(val) _fail += (val)!=0
+#define TEST0(val) if ((val)!=0) { printf("Assertion failed: %s != 0\n", #val); _fail++; }
-#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;
 
 #define ASSERT_EQ(a, b) if ((a) != (b)) { printf("Assertion failed: %s != %s\n", #a, #b); _fail++; }

src/Python/math_bindings.cpp

@@ -162,12 +162,6 @@ void init_math(py::module_ &m) {
       .def_readwrite("direction_error", &HError3f::direction_error);
 
   // 3. Dynamic Vectors (uLib::Vector)
-  py::class_<TRS, AffineTransform, std::shared_ptr<TRS>>(m, "TRS")
-      .def(py::init<>())
-      .def_readwrite("position", &TRS::position)
-      .def_readwrite("rotation", &TRS::rotation)
-      .def_readwrite("scaling", &TRS::scaling);
-
   py::bind_vector<uLib::Vector<Scalari>>(m, "Vector_i")
       .def("MoveToVRAM", &uLib::Vector<Scalari>::MoveToVRAM)
       .def("MoveToRAM", &uLib::Vector<Scalari>::MoveToRAM);
@@ -284,46 +278,23 @@ void init_math(py::module_ &m) {
       .def("SetRotation", &AffineTransform::SetRotation)
       .def("GetRotation", &AffineTransform::GetRotation)
       .def("Rotate",
-           py::overload_cast<const Matrix3f&>(&AffineTransform::Rotate))
+           py::overload_cast<const Matrix3f>(&AffineTransform::Rotate))
       .def("Rotate",
            py::overload_cast<float, Vector3f>(&AffineTransform::Rotate))
       .def("Rotate", py::overload_cast<Vector3f>(&AffineTransform::Rotate))
       .def("EulerYZYRotate", &AffineTransform::EulerYZYRotate)
-      .def("FlipAxes", &AffineTransform::FlipAxes)
+      .def("FlipAxes", &AffineTransform::FlipAxes);
-      .def("SetWorldMatrix", &AffineTransform::SetWorldMatrix);
 
-  py::class_<TRS, AffineTransform, std::shared_ptr<TRS>>(m, "TRS")
+  py::class_<Geometry, AffineTransform, std::shared_ptr<Geometry>>(m, "Geometry")
       .def(py::init<>())
-      .def(py::init<const Matrix4f &>())
+      .def("GetWorldPoint", py::overload_cast<const Vector4f>(
-      .def_readwrite("position", &TRS::position)
+                                &Geometry::GetWorldPoint, py::const_))
-      .def_readwrite("rotation", &TRS::rotation)
+      .def("GetWorldPoint",
-      .def_readwrite("scaling", &TRS::scaling)
+           py::overload_cast<float, float, float>(&Geometry::GetWorldPoint))
-      .def("SetPosition", &TRS::SetPosition)
+      .def("GetLocalPoint", py::overload_cast<const Vector4f>(
-      .def("SetRotation", &TRS::SetRotation)
+                                &Geometry::GetLocalPoint, py::const_))
-      .def("SetOrientation", &TRS::SetOrientation)
+      .def("GetLocalPoint",
-      .def("SetScale", &TRS::SetScale)
+           py::overload_cast<float, float, float>(&Geometry::GetLocalPoint));
-      .def("FromMatrix", &TRS::FromMatrix)
-      .def("GetMatrix", &TRS::GetMatrix);
-
-  py::class_<Geometry, Object, std::shared_ptr<Geometry>>(m, "Geometry")
-      .def("GetParent", &Geometry::GetParent)
-      .def("SetParent", &Geometry::SetParent)
-      .def("GetWorldPoint", py::overload_cast<const Vector4f>(&Geometry::GetWorldPoint, py::const_))
-      .def("GetWorldPoint", py::overload_cast<float, float, float>(&Geometry::GetWorldPoint, py::const_))
-      .def("GetLocalPoint", py::overload_cast<const Vector4f>(&Geometry::GetLocalPoint, py::const_))
-      .def("GetLocalPoint", py::overload_cast<float, float, float>(&Geometry::GetLocalPoint, py::const_));
-
-  py::class_<LinearGeometry, Geometry, std::shared_ptr<LinearGeometry>>(m, "LinearGeometry")
-      .def(py::init<>())
-      .def("Translate", &LinearGeometry::Translate)
-      .def("Rotate", &LinearGeometry::Rotate)
-      .def("Scale", &LinearGeometry::Scale)
-      .def("SetPosition", &LinearGeometry::SetPosition)
-      .def("GetPosition", &LinearGeometry::GetPosition)
-      .def("EulerYZYRotate", &LinearGeometry::EulerYZYRotate)
-      .def("FlipAxes", &LinearGeometry::FlipAxes)
-      .def("GetTransform", &LinearGeometry::GetTransform)
-      .def("SetTransform", &LinearGeometry::SetTransform);
 
   py::class_<ContainerBox, AffineTransform, Object, std::shared_ptr<ContainerBox>>(
       m, "ContainerBox")
@@ -456,7 +427,7 @@ void init_math(py::module_ &m) {
       .def("__getitem__",
            py::overload_cast<const Vector3i &>(&VoxImage<Voxel>::operator[]));
 
-  py::class_<TriangleMesh, TRS, std::shared_ptr<TriangleMesh>>(m, "TriangleMesh")
+  py::class_<TriangleMesh>(m, "TriangleMesh")
       .def(py::init<>())
       .def("AddPoint", &TriangleMesh::AddPoint)
       .def("AddTriangle",
@@ -468,7 +439,7 @@ void init_math(py::module_ &m) {
       .def("GetTriangle", &TriangleMesh::GetTriangle)
       .def("GetNormal", &TriangleMesh::GetNormal);
 
-  py::class_<QuadMesh, TRS, std::shared_ptr<QuadMesh>>(m, "QuadMesh")
+  py::class_<QuadMesh>(m, "QuadMesh")
       .def(py::init<>())
       .def("AddPoint", &QuadMesh::AddPoint)
       .def("AddQuad",

src/Vtk/CMakeLists.txt

@@ -3,6 +3,7 @@ set(HEADERS uLibVtkInterface.h
             vtkHandlerWidget.h
             vtkQViewport.h
             vtkViewport.h
+            vtkPolydata.h
             vtkObjectsContext.h
             )
 
@@ -11,6 +12,7 @@ set(SOURCES uLibVtkInterface.cxx
             vtkHandlerWidget.cpp
             vtkQViewport.cpp
             vtkViewport.cpp
+            vtkPolydata.cpp
             vtkObjectsContext.cpp
             )
 

src/Vtk/HEP/Detectors/vtkDetectorChamber.cxx

@@ -64,7 +64,7 @@ vtkDetectorChamber::vtkDetectorChamber(DetectorChamber *content)
   
   this->SetProp(m_PlaneActor);
   
-  this->Update();
+  this->contentUpdate();
 }
 
 vtkDetectorChamber::~vtkDetectorChamber() {
@@ -76,8 +76,8 @@ DetectorChamber *vtkDetectorChamber::GetContent() {
   return static_cast<DetectorChamber *>(m_Content);
 }
 
-void vtkDetectorChamber::Update() {
+void vtkDetectorChamber::contentUpdate() {
-  this->BaseClass::Update();
+  this->BaseClass::contentUpdate();
 
   if (!m_Content) return;
   DetectorChamber *c = this->GetContent();

src/Vtk/HEP/Detectors/vtkDetectorChamber.h

@@ -56,7 +56,7 @@ public:
 
   Content *GetContent();
 
-  virtual void Update() override;
+  virtual void contentUpdate() override;
 
 protected:
   vtkActor *m_PlaneActor;

src/Vtk/HEP/Detectors/vtkMuonEvent.h

@@ -45,7 +45,7 @@
 
 #include "HEP/Detectors/MuonEvent.h"
 #include "Vtk/uLibVtkInterface.h"
-#include "Vtk/Math/vtkPolydata.h"
+#include "Vtk/vtkPolydata.h"
 
 namespace uLib {
 namespace Vtk {

src/Vtk/HEP/Detectors/vtkMuonScatter.cxx

@@ -40,21 +40,20 @@ namespace Vtk {
 vtkMuonScatter::vtkMuonScatter(MuonScatter &content)
     : m_Content(&content), m_LineIn(vtkLineSource::New()),
       m_LineOut(vtkLineSource::New()), m_PolyData(vtkPolyData::New()),
-      m_SpherePoca(NULL), m_Asm(vtkAssembly::New()) {
+      m_SpherePoca(NULL) {
   InstallPipe();
 }
 
 vtkMuonScatter::vtkMuonScatter(const MuonScatter &content)
     : m_Content(const_cast<MuonScatter *>(&content)),
       m_LineIn(vtkLineSource::New()), m_LineOut(vtkLineSource::New()),
-      m_PolyData(vtkPolyData::New()), m_SpherePoca(NULL), m_Asm(vtkAssembly::New()) {
+      m_PolyData(vtkPolyData::New()), m_SpherePoca(NULL) {
   InstallPipe();
 }
 
 vtkMuonScatter::~vtkMuonScatter() {
   m_LineIn->Delete();
   m_LineOut->Delete();
-  m_Asm->Delete();
   if (m_SpherePoca)
     m_SpherePoca->Delete();
 }
@@ -88,15 +87,13 @@ void vtkMuonScatter::InstallPipe() {
   mapper->SetInputConnection(m_LineIn->GetOutputPort());
   vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(mapper);
-  m_Asm->AddPart(actor);
+  this->SetProp(actor);
 
   mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   mapper->SetInputConnection(m_LineOut->GetOutputPort());
   actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(mapper);
-  m_Asm->AddPart(actor);
+  this->SetProp(actor);
-
-  this->SetProp(m_Asm);
 }
 
 vtkPolyData *vtkMuonScatter::GetPolyData() const {
@@ -126,7 +123,7 @@ void vtkMuonScatter::AddPocaPoint(HPoint3f poca) {
   mapper->SetInputConnection(m_SpherePoca->GetOutputPort());
   vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(mapper);
-  m_Asm->AddPart(actor);
+  this->SetProp(actor);
 }
 
 HPoint3f vtkMuonScatter::GetPocaPoint() {

src/Vtk/HEP/Detectors/vtkMuonScatter.h

@@ -27,7 +27,6 @@
 #define VTKMUONSCATTER_H
 
 #include <vtkActor.h>
-#include <vtkAssembly.h>
 #include <vtkAppendPolyData.h>
 #include <vtkLineSource.h>
 #include <vtkPolyDataMapper.h>
@@ -47,7 +46,7 @@
 
 #include "HEP/Detectors/MuonScatter.h"
 #include "Vtk/uLibVtkInterface.h"
-#include "Vtk/Math/vtkPolydata.h"
+#include "Vtk/vtkPolydata.h"
 
 class vtkRenderWindowInteractor;
 
@@ -86,7 +85,6 @@ private:
   vtkLineSource *m_LineOut;
   vtkSphereSource *m_SpherePoca;
   vtkPolyData *m_PolyData;
-  vtkAssembly *m_Asm;
 };
 
 } // namespace Vtk

src/Vtk/HEP/Geant/vtkGeantEvent.h

@@ -28,7 +28,7 @@
 
 #include "HEP/Geant/GeantEvent.h"
 #include "uLibVtkInterface.h"
-#include "Vtk/Math/vtkPolydata.h"
+#include "vtkPolydata.h"
 #include <vtkActor.h>
 
 namespace uLib {

src/Vtk/HEP/Geant/vtkGeantSolid.h

@@ -28,7 +28,7 @@
 
 #include "HEP/Geant/Solid.h"
 #include "uLibVtkInterface.h"
-#include "Vtk/Math/vtkPolydata.h"
+#include "vtkPolydata.h"
 
 class vtkActor;
 

src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.h

@@ -1,74 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 VTKMUONCONTAINERSCATTERING_H
-#define VTKMUONCONTAINERSCATTERING_H
-
-
-
-#include "Math/Dense.h"
-
-#include "uLibVtkInterface.h"
-#include "Detectors/MuonScatter.h"
-
-class vtkRenderWindowInteractor;
-
-namespace uLib {
-
-class vtkMuonContainerScattering : public Abstract::uLibVtkPolydata {
-    typedef MuonScatter Content;
-public:
-    vtkMuonContainerScattering(const MuonScatter &content);
-    ~vtkMuonScatter();
-
-    Content& GetContent();
-
-    void PrintSelf(std::ostream &o) const;
-
-    virtual vtkProp *GetProp();
-
-    virtual vtkPolyData* GetPolyData() const;
-
-    void AddPocaPoint(HPoint3f poca);
-
-    HPoint3f GetPocaPoint();
-
-    void vtkStartInteractive();
-
-protected:
-    void ConnectInteractor(vtkRenderWindowInteractor *interactor);
-
-private:
-    void InstallPipe();
-
-};
-
-
-}
-
-
-#endif // VTKMUONCONTAINERSCATTERING_H

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.cpp

@@ -50,7 +50,6 @@ vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
       m_RayRepresentation(vtkAppendPolyData::New()),
       m_RayRepresentationActor(vtkActor::New()),
       m_Transform(vtkTransform::New()),
-      m_Asm(vtkAssembly::New()),
       m_HasMuon(false), m_HasPoca(false) {
   default_radius = content.GetImage()->GetSpacing()(0) / 4;
   m_Sphere1->SetRadius(default_radius);
@@ -314,19 +313,20 @@ void vtkVoxRaytracerRepresentation::InstallPipe() {
 
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
+
   mapper->SetInputConnection(append->GetOutputPort());
 
   vtkSmartPointer<vtkActor> actor = vtkActor::New();
   actor->SetMapper(mapper);
   actor->GetProperty()->SetColor(0.6, 0.6, 1);
-  m_Asm->AddPart(actor);
+  this->SetProp(actor);
 
   mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   mapper->SetInputConnection(m_RayLine->GetOutputPort());
 
   m_RayLineActor->SetMapper(mapper);
   m_RayLineActor->GetProperty()->SetColor(1, 0, 0);
-  m_Asm->AddPart(m_RayLineActor);
+  this->SetProp(m_RayLineActor);
 
   vtkSmartPointer<vtkTransformPolyDataFilter> polyfilter =
       vtkSmartPointer<vtkTransformPolyDataFilter>::New();
@@ -343,9 +343,7 @@ void vtkVoxRaytracerRepresentation::InstallPipe() {
   vra->GetProperty()->SetEdgeVisibility(true);
   vra->GetProperty()->SetColor(0.5, 0.5, 0.5);
 
-  m_Asm->AddPart(vra);
+  this->SetProp(vra);
-  
-  this->SetProp(m_Asm);
 }
 
 } // namespace Vtk

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h

@@ -107,7 +107,6 @@ private:
   bool m_HasPoca;
 
   Scalarf default_radius;
-  vtkSmartPointer<vtkAssembly> m_Asm;
   vtkAppendPolyData *m_RayLine;
   vtkActor *m_RayLineActor;
   vtkActor *m_RayRepresentationActor;

src/Vtk/Math/CMakeLists.txt

@@ -11,7 +11,6 @@ set(MATH_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkContainerBox.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkCylinder.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkAssembly.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/vtkPolydata.cpp
     PARENT_SCOPE)
 
 set(MATH_HEADERS
@@ -23,7 +22,6 @@ set(MATH_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkContainerBox.h
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkCylinder.h
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkAssembly.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/vtkPolydata.h
     PARENT_SCOPE)
 
 if(BUILD_TESTING)

src/Vtk/Math/testing/testing-prototype.h

@@ -36,8 +36,6 @@ 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/Vtk/Math/vtkAssembly.cpp

@@ -35,11 +35,12 @@ Assembly::Assembly(uLib::Assembly *content)
       m_ChildContext(nullptr),
       m_BBoxActor(nullptr),
       m_VtkAsm(nullptr),
-      m_InUpdate(false) {
+      m_InUpdate(false),
+      m_BlockUpdate(false) {
     this->InstallPipe();
     if (m_Content) {
         Object::connect(m_Content, &uLib::Assembly::Updated,
-                        this, &Assembly::Update);
+                        this, &Assembly::contentUpdate);
     }
 }
 
@@ -53,7 +54,6 @@ Assembly::~Assembly() {
 void Assembly::InstallPipe() {
     // 1. Create the VTK library assembly that groups everything
     m_VtkAsm = ::vtkAssembly::New();
-    m_VtkAsm->PickableOff();
     this->SetProp(m_VtkAsm);
 
     // 2. Create the bounding-box wireframe actor
@@ -70,7 +70,6 @@ void Assembly::InstallPipe() {
     m_BBoxActor->GetProperty()->SetColor(1.0, 0.85, 0.0);   // gold wireframe
     m_BBoxActor->GetProperty()->SetLineWidth(1.5);
     m_BBoxActor->GetProperty()->SetOpacity(0.6);
-    m_BBoxActor->PickableOff();
     m_BBoxActor->SetVisibility(m_Content ? m_Content->GetShowBoundingBox() : false);
 
     m_VtkAsm->AddPart(m_BBoxActor);
@@ -78,57 +77,71 @@ void Assembly::InstallPipe() {
     // 3. Build a child-objects context (auto-creates puppets for each child)
     if (m_Content) {
         m_ChildContext = new vtkObjectsContext(m_Content);
-        // Link the children context's assembly into our group assembly
+        // The vtkObjectsContext's own prop is already a ::vtkAssembly;
-        if (auto* childProp = vtkProp3D::SafeDownCast(m_ChildContext->GetProp())) {
+        // nest it inside ours so everything moves together.
+        if (auto *childProp = vtkProp3D::SafeDownCast(m_ChildContext->GetProp()))
             m_VtkAsm->AddPart(childProp);
     }
-    }
 
-    // 4. Force initial visual sync
+    // 4. Apply initial transform
-    this->Update();
+    this->UpdateTransform();
+    this->UpdateBoundingBox();
+}
+
+// ------------------------------------------------------------------ //
+void Assembly::contentUpdate() {
+    if (m_InUpdate) return;
+    m_InUpdate = true;
+
+    this->UpdateTransform();
+    this->UpdateBoundingBox();
+    if (m_ChildContext)
+        m_ChildContext->Update();
+
+    m_BlockUpdate = true;
+    Puppet::Update();
+    m_InUpdate = false;
 }
 
 // ------------------------------------------------------------------ //
 void Assembly::Update() {
     if (m_InUpdate) return;
-    m_InUpdate = true;
+    if (!m_Content || !m_VtkAsm) return;
 
-    if (m_Content && m_VtkAsm) {
+    if (m_BlockUpdate) {
-        // Apply world matrix from the assembly content
+        m_BlockUpdate = false;
-        vtkNew<vtkMatrix4x4> m;
+        return;
-        Matrix4fToVtk(m_Content->GetMatrix(), m);
+    }
-        m_VtkAsm->SetUserMatrix(m);
+
-        m_VtkAsm->Modified();
+    m_InUpdate = true;
+
+    // Pull VTK transform back into the uLib model
+    vtkMatrix4x4* vmat = m_VtkAsm->GetUserMatrix();
+    if (vmat) {
+        Matrix4f transform = VtkToMatrix4f(vmat);
+        m_Content->SetMatrix(transform);
     }
 
-    this->Puppet::Update();
     this->UpdateBoundingBox();
     if (m_ChildContext)
         m_ChildContext->Update();
-    m_InUpdate = false;
-}
-
-void Assembly::SyncFromVtk() {
-    if (m_InUpdate) return;
-    if (!m_Content || !m_VtkAsm) return;
-
-    m_InUpdate = true;
-
-    // VTK -> Model: Update world matrix (accounting for model parents)
-    if (vtkProp3D* proxy = this->GetProxyProp()) {
-        m_Content->SetWorldMatrix(VtkToMatrix4f(proxy->GetUserMatrix()));
-        m_Content->FromMatrix(m_Content->GetMatrix());
-    }
-
-    this->UpdateBoundingBox();
-    if (m_ChildContext)
-        m_ChildContext->SyncFromVtk();
 
     m_Content->Updated(); // Notify change in model
 
     m_InUpdate = false;
 }
 
+// ------------------------------------------------------------------ //
+void Assembly::UpdateTransform() {
+    if (!m_Content || !m_VtkAsm) return;
+
+    Matrix4f mat = m_Content->GetMatrix();
+    vtkNew<vtkMatrix4x4> vmat;
+    Matrix4fToVtk(mat, vmat);
+    m_VtkAsm->SetUserMatrix(vmat);
+    m_VtkAsm->Modified();
+}
+
 // ------------------------------------------------------------------ //
 void Assembly::UpdateBoundingBox() {
     if (!m_Content || !m_BBoxActor) return;

src/Vtk/Math/vtkAssembly.h

@@ -36,7 +36,7 @@ class vtkObjectsContext; // forward
  */
 class Assembly : public Puppet {
 public:
-    uLibTypeMacro(Assembly, Puppet)
+    virtual const char *GetClassName() const override { return "Vtk.Assembly"; }
 
     Assembly(uLib::Assembly *content);
     virtual ~Assembly();
@@ -44,20 +44,16 @@ public:
     /** @brief Updates the VTK representation from the model (model→VTK). */
     virtual void Update() override;
 
-    /** @brief Synchronizes the model from the VTK representation (VTK→model). */
-    virtual void SyncFromVtk() override;
-
     virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
-    virtual uLib::ObjectsContext* GetChildren() override { return (uLib::ObjectsContext*)m_Content; }
 
-    /**
+    /** @brief Called when the model signals an update (model→VTK push). */
-     * @brief Returns the puppet managing child objects.
+    void contentUpdate();
-     */
 
     /** @brief Returns the puppet managing child objects. */
     vtkObjectsContext *GetChildrenContext() const;
 
 private:
+    void UpdateTransform();
     void UpdateBoundingBox();
     void InstallPipe();
 
@@ -66,6 +62,7 @@ private:
     vtkActor           *m_BBoxActor;
     ::vtkAssembly      *m_VtkAsm; // VTK library assembly — NOT this class
     bool                m_InUpdate;    // re-entrancy guard
+    bool                m_BlockUpdate; // block feedback from contentUpdate→Update
 };
 
 } // namespace Vtk

src/Vtk/Math/vtkContainerBox.cpp

@@ -50,26 +50,16 @@ namespace Vtk {
 struct ContainerBoxData {
   vtkSmartPointer<vtkActor> m_Cube;
   vtkSmartPointer<vtkActor> m_Axes;
-  vtkSmartPointer<vtkAssembly>  m_VtkAsm;
-  vtkSmartPointer<vtkMatrix4x4> m_Affine;
-  uLib::Connection              m_UpdateSignal;
 
-  ContainerBoxData() : m_Cube(vtkSmartPointer<vtkActor>::New()), 
+  ContainerBoxData() : m_Cube(vtkSmartPointer<vtkActor>::New()), m_Axes(vtkSmartPointer<vtkActor>::New()) {}
-                       m_Axes(vtkSmartPointer<vtkActor>::New()), 
-                       m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()),
-                       m_Affine(vtkSmartPointer<vtkMatrix4x4>::New()) {}
   ~ContainerBoxData() {
   }
 };
 
-
-
-
-
 vtkContainerBox::vtkContainerBox(vtkContainerBox::Content *content)
     : d(new ContainerBoxData()), m_Content(content) {
   this->InstallPipe();
-  d->m_UpdateSignal = Object::connect(m_Content, &uLib::Object::Updated, this, &vtkContainerBox::Update);
+  Object::connect(m_Content, &Content::Updated, this, &vtkContainerBox::contentUpdate);
 }
 
 vtkContainerBox::~vtkContainerBox() {
@@ -82,50 +72,63 @@ vtkPolyData *vtkContainerBox::GetPolyData() const {
 }
 
 
+void vtkContainerBox::contentUpdate() {
+  RecursiveMutex::ScopedLock lock(this->m_UpdateMutex);
+  if (!m_Content)
+    return;
+
+  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
+  if (!root) return;
+
+  vtkMatrix4x4* vmat = root->GetUserMatrix();
+  if (!vmat) {
+    // Should have been set in InstallPipe, but let's be safe
+    vtkNew<vtkMatrix4x4> mat;
+    root->SetUserMatrix(mat);
+    vmat = mat;
+  }
+
+  d->m_Cube->SetUserMatrix(nullptr);
+  d->m_Axes->SetUserMatrix(nullptr);
+
+  Matrix4f transform = m_Content->GetMatrix();
+  Matrix4fToVtk(transform, vmat);
+
+  root->Modified();
+  m_BlockUpdate = true;
+  Puppet::Update();
+}
+
+
 void vtkContainerBox::Update() {
   RecursiveMutex::ScopedLock lock(this->m_UpdateMutex);
   if (!m_Content) return;
   
-  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
+  if (m_BlockUpdate) {
-  if (root) {
+    m_BlockUpdate = false;
-      // Apply local full matrix (TRS * LocalBox) so that nested assemblies work correctly
+    return;
-      Matrix4f fullLocal = m_Content->GetMatrix() * m_Content->GetLocalMatrix();
-      vtkNew<vtkMatrix4x4> m;
-      Matrix4fToVtk(fullLocal, m);
-      root->SetUserMatrix(m);
-      root->Modified();
   }
 
-  // Delegate rest of update (appearance, render, etc)
+  // Use Targeted Blocking: only block the feedback connection to this puppet
-  ConnectionBlock blocker(d->m_UpdateSignal);
+  // boost::signals2::shared_connection_block block(m_Connection);
-  this->Puppet::Update();
-}
 
+  vtkProp3D* assembly = vtkProp3D::SafeDownCast(this->GetProp());
+  if (!assembly) return;
 
-void vtkContainerBox::SyncFromVtk() {
+  vtkMatrix4x4* vmat = assembly->GetUserMatrix();
-  RecursiveMutex::ScopedLock lock(this->m_UpdateMutex);
+  if (!vmat) return;
-  if (!m_Content) return;
   
-  vtkProp3D* root = this->GetProxyProp();
+  Matrix4f transform = VtkToMatrix4f(vmat);
-  if (!root) return;
 
-  // VTK -> Model: Extract new world TRS from proxy, which matches the model's TRS center
+  // Update uLib model's affine transform
-  vtkMatrix4x4* rootMat = root->GetUserMatrix();
+  // if (m_Content->GetParent()) {
-  // if (rootMat) {
+  //   Matrix4f localT = m_Content->GetParent()->GetWorldMatrix().inverse() * transform;
-  //     std::cout << "[vtkContainerBox::SyncFromVtk] Read Proxy UserMatrix:" << std::endl;
+  //   m_Content->SetMatrix(localT);
-  //     rootMat->Print(std::cout);
+  // } else {
+  m_Content->SetMatrix(transform);
   // }
 
-  Matrix4f vtkWorld = VtkToMatrix4f(rootMat);
+  m_Content->Updated(); // Notify change
-  
-  // Synchronize TRS property members from the updated local matrix
-  m_Content->FromMatrix(vtkWorld);
-
-  // std::cout << "[vtkContainerBox::SyncFromVtk] New Model WorldMatrix:" << std::endl << m_Content->GetWorldMatrix() << std::endl;
-
-  // Since we modified the model, notify observers, but block the loop back to VTK
-  // ConnectionBlock blocker(d->m_UpdateSignal);
-  m_Content->Updated();
 }
 
 
@@ -167,16 +170,15 @@ void vtkContainerBox::InstallPipe() {
   mapper->SetInputConnection(axes->GetOutputPort());
   mapper->Update();
   
-  d->m_VtkAsm->AddPart(d->m_Cube);
+  this->SetProp(d->m_Cube);
-  d->m_VtkAsm->AddPart(d->m_Axes);
+  this->SetProp(d->m_Axes);
-  this->SetProp(d->m_VtkAsm);
   
-  vtkProp3D* root = d->m_VtkAsm;
+  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
   if (root) {
-      d->m_Affine = Matrix4fToVtk(m_Content->GetMatrix());
+      vtkNew<vtkMatrix4x4> vmat;
-      root->SetUserMatrix(d->m_Affine);
+      Matrix4fToVtk(c->GetMatrix(), vmat);
+      root->SetUserMatrix(vmat);
   }
-  this->Update();
 }
 
 } // namespace Vtk

src/Vtk/Math/vtkContainerBox.h

@@ -29,6 +29,7 @@
 #include "Math/ContainerBox.h"
 #include "uLibVtkInterface.h"
 #include "vtkPolydata.h"
+#include <boost/signals2/connection.hpp>
 
 class vtkActor;
 
@@ -46,15 +47,9 @@ public:
 
   virtual class vtkPolyData *GetPolyData() const;
 
-  /**
+  virtual void contentUpdate();
-   * @brief Updates the VTK representation from the internal state.
-   */
-  virtual void Update() override;
 
-  /**
+  virtual void Update();
-   * @brief Synchronizes the model from the VTK representation (VTK→model).
-   */
-  virtual void SyncFromVtk() override;
 
   virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
 
@@ -64,7 +59,6 @@ protected:
   struct ContainerBoxData *d;
   Content                 *m_Content;
   bool                     m_BlockUpdate = false;
-  
 };
 
 } // namespace Vtk

src/Vtk/Math/vtkCylinder.cpp

@@ -40,7 +40,7 @@ namespace Vtk {
 vtkCylinder::vtkCylinder(vtkCylinder::Content *content)
     : m_Content(content), m_Actor(nullptr), m_VtkAsm(nullptr) {
   this->InstallPipe();
-  m_UpdateSignal = Object::connect(m_Content, &uLib::Object::Updated, this, &vtkCylinder::Update);
+  Object::connect(m_Content, &Content::Updated, this, &vtkCylinder::contentUpdate);
 }
 
 vtkCylinder::~vtkCylinder() {
@@ -48,19 +48,24 @@ vtkCylinder::~vtkCylinder() {
   if (m_VtkAsm) m_VtkAsm->Delete();
 }
 
-void vtkCylinder::Update() {
+void vtkCylinder::contentUpdate() {
   if (!m_Content)
     return;
 
   vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
-  if (root) {
+  if (!root) return;
-      // 1. Placement handled specifically from content (use TRS GetMatrix, not World)
+
-      vtkNew<vtkMatrix4x4> m;
+  // 1. Placement (Position/Rotation/Model-level Scale) goes to the root prop
-      Matrix4fToVtk(m_Content->GetMatrix(), m);
+  vtkMatrix4x4* vmat = root->GetUserMatrix();
-      root->SetUserMatrix(m);
+  if (!vmat) {
+    vtkNew<vtkMatrix4x4> mat;
+    root->SetUserMatrix(mat);
+    vmat = mat;
+  }
+  Matrix4f transform = m_Content->GetMatrix();
+  Matrix4fToVtk(transform, vmat);
 
   // 2. Shape-local properties (Radius, Height, Axis alignment) go to the internal actor
-      // These are relative to the root assembly
   vtkTransform* alignment = vtkTransform::SafeDownCast(m_Actor->GetUserTransform());
   if (alignment) {
       alignment->Identity();
@@ -78,32 +83,21 @@ void vtkCylinder::Update() {
   }
 
   root->Modified();
-  }
+  Puppet::Update();
-
-  // Delegate rest of update (appearance, render, etc)
-  ConnectionBlock blocker(m_UpdateSignal);
-  this->Puppet::Update();
 }
 
-void vtkCylinder::SyncFromVtk() {
+void vtkCylinder::Update() {
   if (!m_Content) return;
 
-  vtkProp3D* root = this->GetProxyProp();
+  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
   if (!root) return;
 
-  // VTK -> Model: Extract new world TRS from proxy
+  vtkMatrix4x4* vmat = root->GetUserMatrix();
-  vtkMatrix4x4* rootMat = root->GetUserMatrix();
+  if (!vmat) return;
-  if (rootMat) {
-      std::cout << "[vtkCylinder::SyncFromVtk] Read Proxy UserMatrix:" << std::endl;
-      rootMat->Print(std::cout);
-  }
   
-  Matrix4f vtkWorld = VtkToMatrix4f(rootMat);
+  // Pull the placement matrix directly from VTK
-  
+  Matrix4f transform = VtkToMatrix4f(vmat);
-  // Directly sync model from the world matrix
+  m_Content->SetMatrix(transform);
-  m_Content->FromMatrix(vtkWorld);
-
-  std::cout << "[vtkCylinder::SyncFromVtk] New Model WorldMatrix:" << std::endl << m_Content->GetWorldMatrix() << std::endl;
 
   m_Content->Updated();
 }
@@ -132,7 +126,7 @@ void vtkCylinder::InstallPipe() {
 
   m_VtkAsm->AddPart(m_Actor);
 
-  this->Update();
+  this->contentUpdate();
 }
 
 } // namespace Vtk

src/Vtk/Math/vtkCylinder.h

@@ -48,11 +48,11 @@ public:
   vtkCylinder(Content *content);
   virtual ~vtkCylinder();
 
-  /** Synchronizes the VTK actor with the uLib model matrix and vice-versa */
+  /** Synchronizes the VTK actor with the uLib model matrix */
-  virtual void Update() override;
+  virtual void contentUpdate();
 
-  /** Synchronizes the uLib model matrix with the VTK actor specifically for gizmo interactions */
+  /** Synchronizes the uLib model matrix with the VTK actor (e.g., after UI manipulation) */
-  virtual void SyncFromVtk() override;
+  virtual void Update();
 
   virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
 
@@ -63,7 +63,6 @@ protected:
   vtkActor *m_Actor;
   ::vtkAssembly *m_VtkAsm;
   Content *m_Content;
-  uLib::Connection m_UpdateSignal;
 };
 
 } // namespace Vtk

src/Vtk/Math/vtkQuadMesh.h

@@ -28,7 +28,7 @@
 
 #include "Math/QuadMesh.h"
 #include "Vtk/uLibVtkInterface.h"
-#include "Vtk/Math/vtkPolydata.h"
+#include "Vtk/vtkPolydata.h"
 
 class vtkPolyData;
 class vtkActor;

src/Vtk/Math/vtkTriangleMesh.h

@@ -28,7 +28,7 @@
 
 #include "Math/TriangleMesh.h"
 #include "Vtk/uLibVtkInterface.h"
-#include "Vtk/Math/vtkPolydata.h"
+#include "Vtk/vtkPolydata.h"
 
 class vtkPolyData;
 class vtkActor;

src/Vtk/Math/vtkVoxImage.cpp

@@ -41,7 +41,6 @@
 #include <vtkPiecewiseFunction.h>
 #include <vtkSmartVolumeMapper.h>
 #include <vtkVolumeProperty.h>
-#include <vtkMatrix4x4.h>
 
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
@@ -50,7 +49,6 @@
 #include <Math/VoxImage.h>
 
 #include "Vtk/Math/vtkVoxImage.h"
-#include "Vtk/Math/vtkDense.h"
 
 #include <vtkAutoInit.h>
 VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
@@ -126,30 +124,20 @@ void vtkVoxImage::SetContent() {
 
 vtkVoxImage::vtkVoxImage(Content &content)
     : m_Content(content), m_Actor(vtkVolume::New()),
-      m_Asm(vtkAssembly::New()),
       m_Image(vtkImageData::New()), m_Outline(vtkCubeSource::New()),
       m_OutlineActor(vtkActor::New()),
       m_Reader(NULL), m_Writer(NULL), writer_factor(1.E6),
-      m_Window(1.0), m_Level(0.5), m_ShadingPreset(0) {
+      m_Window(40/1.E6), m_Level(20/1.E6), m_ShadingPreset(0) {
-  // Transfer functions
-  m_ColorFun = vtkColorTransferFunction::New();
-  m_OpacityFun = vtkPiecewiseFunction::New();
-  m_UpdateConnection = Object::connect(&m_Content, &uLib::Object::Updated, this, &vtkVoxImage::Update);
-  
   GetContent();
   InstallPipe();
-  RescaleShaderRange();
   ULIB_ACTIVATE_DISPLAY_PROPERTIES;
 }
 
 vtkVoxImage::~vtkVoxImage() {
   m_Image->Delete();
   m_Actor->Delete();
-  m_Asm->Delete();
   m_Outline->Delete();
   m_OutlineActor->Delete();
-  m_ColorFun->Delete();
-  m_OpacityFun->Delete();
 }
 
 vtkImageData *vtkVoxImage::GetImageData() {
@@ -191,7 +179,6 @@ void vtkVoxImage::ReadFromVKTFile(const char *fname) {
 
     m_Image->DeepCopy(vtkscale->GetOutput());
     SetContent();
-    RescaleShaderRange();
   } else {
     std::cerr << "Error: file does not contain structured points\n";
   }
@@ -211,134 +198,115 @@ void vtkVoxImage::ReadFromXMLFile(const char *fname) {
 
   m_Image->DeepCopy(vtkscale->GetOutput());
   SetContent();
-  RescaleShaderRange();
 }
 
 void vtkVoxImage::setShadingPreset(int blendType) {
   m_ShadingPreset = blendType;
   vtkSmartVolumeMapper *mapper = (vtkSmartVolumeMapper *)m_Actor->GetMapper();
-  if (!mapper) return;
   vtkVolumeProperty *property = m_Actor->GetProperty();
 
+  static vtkColorTransferFunction *colorFun = vtkColorTransferFunction::New();
+  static vtkPiecewiseFunction *opacityFun = vtkPiecewiseFunction::New();
+
   float window = m_Window;
   float level = m_Level;
 
-  property->SetColor(m_ColorFun);
+  property->SetColor(colorFun);
-  property->SetScalarOpacity(m_OpacityFun);
+  property->SetScalarOpacity(opacityFun);
   property->SetInterpolationTypeToLinear();
 
-  m_ColorFun->RemoveAllPoints();
+  if (blendType != 6) {
-  m_OpacityFun->RemoveAllPoints();
+    colorFun->RemoveAllPoints();
+    opacityFun->RemoveAllPoints();
+  }
 
   switch (blendType) {
-  case 0: // MIP
+  case 0:
-    m_ColorFun->AddRGBPoint(level - 0.5 * window, 0, 0, 0);
+    colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
-    m_ColorFun->AddRGBPoint(level + 0.5 * window, 1, 1, 1);
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window,
-    m_OpacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window, 1.0);
+                           1.0);
     mapper->SetBlendModeToMaximumIntensity();
     break;
-  case 1: // Composite
+  case 1:
-    m_ColorFun->AddRGBPoint(level - 0.5 * window, 0, 0, 0);
+    colorFun->AddRGBSegment(level - 0.5 * window, 0.0, 0.0, 0.0,
-    m_ColorFun->AddRGBPoint(level + 0.5 * window, 1, 1, 1);
+                            level + 0.5 * window, 1.0, 1.0, 1.0);
-    m_OpacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window, 1.0);
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window,
+                           1.0);
     mapper->SetBlendModeToComposite();
     property->ShadeOff();
     break;
-  case 2: // Composite Shaded
+  case 2:
-    m_ColorFun->AddRGBPoint(level - 0.5 * window, 0, 0, 0);
+    colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
-    m_ColorFun->AddRGBPoint(level + 0.5 * window, 1, 1, 1);
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window,
-    m_OpacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window, 1.0);
+                           1.0);
     mapper->SetBlendModeToComposite();
     property->ShadeOn();
     break;
-  case 3: // Rainbow MIP
+  case 3:
-    m_ColorFun->AddRGBPoint(level - 0.5 * window, 0, 0, 1);
+    colorFun->AddRGBPoint(-3024, 0, 0, 0, 0.5, 0.0);
-    m_ColorFun->AddRGBPoint(level, 0, 1, 0);
+    colorFun->AddRGBPoint(-1000, .62, .36, .18, 0.5, 0.0);
-    m_ColorFun->AddRGBPoint(level + 0.5 * window, 1, 1, 0);
+    colorFun->AddRGBPoint(-500, .88, .60, .29, 0.33, 0.45);
-    m_ColorFun->AddRGBPoint(level + window, 1, 0, 0);
+    colorFun->AddRGBPoint(3071, .83, .66, 1, 0.5, 0.0);
-    m_OpacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window, 1.0);
+    opacityFun->AddPoint(-3024, 0, 0.5, 0.0);
+    opacityFun->AddPoint(-1000, 0, 0.5, 0.0);
+    opacityFun->AddPoint(-500, 1.0, 0.33, 0.45);
+    opacityFun->AddPoint(3071, 1.0, 0.5, 0.0);
+    mapper->SetBlendModeToComposite();
+    property->ShadeOn();
+    property->SetAmbient(0.1);
+    property->SetDiffuse(0.9);
+    property->SetSpecular(0.2);
+    property->SetSpecularPower(10.0);
+    property->SetScalarOpacityUnitDistance(0.8919);
+    break;
+  case 4:
+    colorFun->AddRGBPoint(0.0, 0, 0, 1); // Blue
+    colorFun->AddRGBPoint(level, 0, 1, 0); // Green
+    colorFun->AddRGBPoint(level + 0.5*window, 1, 1, 0); // Yellow
+    colorFun->AddRGBPoint(level + window, 1, 0, 0); // Red
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window, 1.0);
     mapper->SetBlendModeToMaximumIntensity();
     break;
-  case 4: // Additive
+  case 5:
-    m_ColorFun->AddRGBPoint(level - 0.5 * window, 0, 0, 0);
+    colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
-    m_ColorFun->AddRGBPoint(level + 0.5 * window, 1, 1, 1);
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window, 1.0);
-    m_OpacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window, 1.0);
     mapper->SetBlendModeToAdditive();
     break;
   default:
+    vtkGenericWarningMacro("Unknown blend type.");
     break;
   }
 }
 
-void vtkVoxImage::RescaleShaderRange() {
-  double range[2];
-  m_Image->GetScalarRange(range);
-  m_Level = (range[0] + range[1]) / 2.0;
-  m_Window = range[1] - range[0];
-  if (m_Window <= 1e-9)
-    m_Window = 1.0;
-  setShadingPreset(m_ShadingPreset);
-}
-
 void vtkVoxImage::SetRepresentation(Representation mode) {
-  Puppet::SetRepresentation(mode); // Ensure base class data state is updated
-
   if (mode == Wireframe) {
     m_Actor->SetVisibility(0);
     m_OutlineActor->SetVisibility(1);
-    m_OutlineActor->GetProperty()->SetRepresentationToWireframe();
+  } else if (mode == Surface) {
-  } else if (mode == Volume) {
     m_Actor->SetVisibility(1);
-    m_OutlineActor->SetVisibility(1);
+    m_OutlineActor->SetVisibility(1); // Keep outline visible as boundary
-    m_OutlineActor->GetProperty()->SetRepresentationToWireframe();
   } else {
-    // Other representations (Points, Surface, etc) are handled by basic Puppet
+      Puppet::SetRepresentation(mode);
-    // behavior which affects the m_Asm parts.
   }
 }
 
 void vtkVoxImage::serialize_display(uLib::Archive::display_properties_archive & ar, const unsigned int version) {
-    // Call base class to show Transform and Appearance properties
+    // Call base class if it has display properties
-    // Puppet::serialize_display(ar, version);
+    Puppet::serialize_display(ar, version);
     
-    // Use the member variables for volume rendering parameters
+    // Use the member variables if they are available
     ar & boost::serialization::make_hrp("Window", m_Window);
     ar & boost::serialization::make_hrp("Level", m_Level);
-    ar & boost::serialization::make_hrp_enum("Shading", m_ShadingPreset, 
+    ar & boost::serialization::make_hrp_enum("Shading", m_ShadingPreset, {"MIP", "Composite", "Composite Shaded", "MIP Bone", "MIP Hot", "Additive"});
-      {"MIP", "Composite", "Composite Shaded", "MIP Bone", "MIP Hot", "Additive"});
-}
-
-void vtkVoxImage::SyncFromVtk() {
-  if (auto *root = this->GetProxyProp()) {
-    vtkMatrix4x4 *rootMat = root->GetUserMatrix();
-    if (rootMat) {
-      Matrix4f vtkLocal = VtkToMatrix4f(rootMat);
-      // Synchronize TRS from VTK, compensating for local volume offset
-      m_Content.FromMatrix(vtkLocal); // * m_Content.GetLocalMatrix().inverse());
-      m_Content.Updated();
-    }
-  }
 }
 
 void vtkVoxImage::Update() {
-  if (auto *root = vtkProp3D::SafeDownCast(this->GetProp())) {
-    vtkNew<vtkMatrix4x4> m;
-    Matrix4fToVtk(m_Content.GetMatrix(), m); // * m_Content.GetLocalMatrix(), m);
-    root->SetUserMatrix(m);
-    root->Modified();
-    // std::cout << "[vtkVoxImage::Update] Set Proxy UserMatrix:" << std::endl;
-    // std::cout << m_Content.GetMatrix() << std::endl;
-  }
   setShadingPreset(m_ShadingPreset);
   m_Actor->Update();
   m_Outline->SetBounds(m_Image->GetBounds());
   m_Outline->Update();
-
-  ConnectionBlock blocker(m_UpdateConnection);
-  this->Puppet::Update();
 }
 
-
 void vtkVoxImage::InstallPipe() {
   vtkSmartPointer<vtkSmartVolumeMapper> mapper =
       vtkSmartPointer<vtkSmartVolumeMapper>::New();
@@ -350,7 +318,7 @@ void vtkVoxImage::InstallPipe() {
   mapper->Update();
 
   m_Actor->SetMapper(mapper);
-  this->setShadingPreset(m_ShadingPreset);
+  this->setShadingPreset(0);
   mapper->Update();
 
   m_Outline->SetBounds(m_Image->GetBounds());
@@ -362,12 +330,11 @@ void vtkVoxImage::InstallPipe() {
   m_OutlineActor->GetProperty()->SetRepresentationToWireframe();
   m_OutlineActor->GetProperty()->SetAmbient(0.7);
 
-  m_Asm->AddPart(m_Actor);
+  this->SetProp(m_Actor);
-  m_Asm->AddPart(m_OutlineActor);
+  this->SetProp(m_OutlineActor);
-  this->SetProp(m_Asm);
   
   // Default look
-  this->SetRepresentation(Volume);
+  this->SetRepresentation(Surface);
 }
 
 } // namespace Vtk

src/Vtk/Math/vtkVoxImage.h

@@ -31,7 +31,6 @@
 #include <vtkVolume.h>
 #include <vtkXMLImageDataReader.h>
 #include <vtkXMLImageDataWriter.h>
-#include <vtkAssembly.h>
 
 #include <Math/VoxImage.h>
 
@@ -39,8 +38,6 @@
 
 class vtkImageData;
 class vtkActor;
-class vtkColorTransferFunction;
-class vtkPiecewiseFunction;
 
 namespace uLib {
 namespace Vtk {
@@ -57,8 +54,6 @@ public:
 
   void SetContent();
 
-  vtkProp3D *GetProp() override { return m_Asm; }
-
   vtkImageData *GetImageData();
 
   void SaveToXMLFile(const char *fname);
@@ -69,10 +64,8 @@ public:
 
   void setShadingPreset(int blendType = 2);
   void SetRepresentation(Representation mode);
-  void RescaleShaderRange();
 
   void Update() override;
-  void SyncFromVtk() override;
   void serialize_display(uLib::Archive::display_properties_archive & ar, const unsigned int version = 0) override;
 
 protected:
@@ -84,7 +77,6 @@ private:
   vtkImageData *m_Image;
   vtkCubeSource *m_Outline;
   vtkActor *m_OutlineActor;
-  vtkAssembly *m_Asm;
 
   vtkXMLImageDataReader *m_Reader;
   vtkXMLImageDataWriter *m_Writer;
@@ -94,11 +86,6 @@ private:
   float m_Window;
   float m_Level;
   int m_ShadingPreset;
-
-  Connection m_UpdateConnection;
-
-  class vtkColorTransferFunction *m_ColorFun;
-  class vtkPiecewiseFunction *m_OpacityFun;
 };
 
 } // namespace Vtk

src/Vtk/testing/CMakeLists.txt

@@ -3,8 +3,6 @@ set(TESTS
         vtkViewerTest
         vtkHandlerWidget
         PuppetPropertyTest
-        PuppetParentingTest
-        vtkQViewportTest
         # vtkVoxImageTest
 #	vtkTriangleMeshTest
 )

src/Vtk/testing/PuppetParentingTest.cpp

@@ -1,106 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 <cstdlib>
-#include <Core/ObjectsContext.h>
-#include <Math/Assembly.h>
-#include <Math/ContainerBox.h>
-#include <Vtk/uLibVtkViewer.h>
-#include <Vtk/vtkObjectsContext.h>
-#include <Vtk/Math/vtkAssembly.h>
-#include <Vtk/Math/vtkContainerBox.h>
-#include <vtkAssembly.h>
-#include <vtkProp3D.h>
-#include <vtkRenderer.h>
-#include <vtkMatrix4x4.h>
-#include "testing-prototype.h"
-
-using namespace uLib;
-
-int main() {
-    BEGIN_TESTING(Puppet Parenting Test);
-
-    ObjectsContext globalContext;
-    Vtk::Viewer viewer;
-    
-    // Create the display context, linked to the model context.
-    // It will automatically create visual puppets for each model object.
-    Vtk::vtkObjectsContext viewerContext(&globalContext);
-    viewerContext.ConnectRenderer(viewer.GetRenderer());
-
-    // 1. Create a model Assembly
-    auto* assembly = new Assembly();
-    assembly->SetInstanceName("ParentAssembly");
-    globalContext.AddObject(assembly);
-
-    // Verify assembly puppet exists in the viewer context
-    Vtk::Puppet* assemblyPuppet = viewerContext.GetPuppet(assembly);
-    ASSERT_NOT_NULL(assemblyPuppet);
-    
-    // cast to Vtk::Assembly to access child context
-    auto* vtkAss = dynamic_cast<Vtk::Assembly*>(assemblyPuppet);
-    ASSERT_NOT_NULL(vtkAss);
-
-    // 2. Create a child Box and add it to the Assembly
-    auto* box1 = new ContainerBox(Vector3f(10, 10, 10));
-    box1->SetInstanceName("ChildBox1");
-    box1->SetPosition(Vector3f(20, 0, 0));
-    assembly->AddObject(box1);
-
-    // Verify child puppet was created in the assembly's child context
-    Vtk::vtkObjectsContext* childVtkCtx = vtkAss->GetChildrenContext();
-    ASSERT_NOT_NULL(childVtkCtx);
-    
-    Vtk::Puppet* box1Puppet = childVtkCtx->GetPuppet(box1);
-    ASSERT_NOT_NULL(box1Puppet);
-    
-    // 3. Move the parent and verify the child follows
-    assembly->SetPosition(Vector3f(100, 0, 0));
-    assembly->Updated();
-    
-    // In VTK assemblies, the child's absolute matrix should reflect the parent's transform
-    vtkProp3D* box1Prop = vtkProp3D::SafeDownCast(box1Puppet->GetProp());
-    ASSERT_NOT_NULL(box1Prop);
-    
-    vtkMatrix4x4* boxMatrix = box1Prop->GetMatrix();
-    // Origin (0,0,0) + local(20,0,0) + assembly(100,0,0) = world(120,0,0) ?
-    // Actually, box1->GetPosition() is (20,0,0).
-    // The puppet ApplyTransform sets the prop orientation and position.
-    
-    std::cout << "Checking transformation chain..." << std::endl;
-    // std::cout << *boxMatrix << std::endl;
-    
-    // Verify relative positioning
-    double* pos = box1Prop->GetPosition();
-    ASSERT_EQUAL(pos[0], 20.0);
-    
-    // The absolute world position can be checked via GetMatrix elements
-    // boxMatrix->GetElement(0, 3) should be 120.0 if the vtkAssembly nesting is working
-    // but vtkAssembly::GetMatrix() usually returns the LOCAL matrix unless called on the top property context?
-    // Actually vtkProp3D::GetMatrix() is the local matrix.
-    
-    // 4. Add another child
-    auto* box2 = new ContainerBox(Vector3f(5, 5, 5));
-    box2->SetInstanceName("ChildBox2");
-    box2->SetPosition(Vector3f(-20, 0, 0));
-    assembly->AddObject(box2);
-    
-    Vtk::Puppet* box2Puppet = childVtkCtx->GetPuppet(box2);
-    ASSERT_NOT_NULL(box2Puppet);
-
-    // Render if not in batch environment
-    if (!std::getenv("CTEST_PROJECT_NAME")) {
-       viewer.GetRenderer()->ResetCamera();
-       viewer.Start();
-    }
-
-    END_TESTING;
-}

src/Vtk/testing/testing-prototype.h

@@ -36,8 +36,6 @@ 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/Vtk/testing/vtkQViewportTest.cpp

@@ -1,87 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <QApplication>
-#include <QtGlobal>
-#include <Vtk/vtkQViewport.h>
-
-#include <vtkSmartPointer.h>
-#include <vtkCubeSource.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkActor.h>
-#include <vtkProperty.h>
-#include <vtkRenderer.h>
-
-#include "testing-prototype.h"
-
-using namespace uLib;
-
-int main(int argc, char** argv)
-{
-    // Force X11 on Linux to avoid Wayland connection issues in headless/X11 environments
-#if defined(Q_OS_LINUX)
-    qputenv("QT_QPA_PLATFORM", "xcb");
-#endif
-
-    BEGIN_TESTING(vtk QViewport Test);
-
-    QApplication app(argc, argv);
-    app.processEvents();
-
-    Vtk::QViewport viewport;
-    viewport.resize(800, 600);
-    viewport.show();
-
-    vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
-    cube->SetXLength(10);
-    cube->SetYLength(10);
-    cube->SetZLength(10);
-    cube->Update();
-
-    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(cube->GetOutputPort());
-    
-    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
-    actor->SetMapper(mapper);
-    actor->GetProperty()->SetColor(1, 0, 0);
-
-    viewport.addProp(actor);
-    viewport.Render();
-
-    ASSERT_NOT_NULL(viewport.GetRenderWindow());
-    ASSERT_NOT_NULL(viewport.GetRenderer());
-
-    if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
-        // Run application for a while to see the result
-        return app.exec();
-    }
-    
-
-    END_TESTING;
-}

src/Vtk/uLibVtkInterface.cxx

@@ -41,7 +41,6 @@
 #include <vtkVersion.h>
 #include "vtkViewport.h"
 #include "uLibVtkInterface.h"
-#include "Math/Transform.h"
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
@@ -58,15 +57,12 @@
 #include <vtkPolyData.h>
 #include <vtkFeatureEdges.h>
 #include <vtkTransform.h>
-#include <vtkCubeSource.h>
 #include <vtkRenderWindow.h>
 
 #include "uLibVtkInterface.h"
 #include "vtkHandlerWidget.h"
 #include "Math/Dense.h"
-#include "Vtk/Math/vtkDense.h"
 #include "Core/Property.h"
-#include "Math/Transform.h"
 
 
 
@@ -78,34 +74,41 @@ namespace uLib {
 namespace Vtk {
 
 
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// PUPPET //
+
 // PIMPL -------------------------------------------------------------------- //
 
 class PuppetData {
 public:
-    PuppetData(Puppet* owner) :
+    PuppetData() :
-        m_Puppet(owner),
         m_Renderers(vtkSmartPointer<vtkRendererCollection>::New()),
-        m_Prop(nullptr),
+        m_Assembly(vtkSmartPointer<vtkAssembly>::New()),
         m_ShowBoundingBox(false),
         m_ShowScaleMeasures(false),
         m_Representation(Puppet::Surface),
-        m_Opacity(1.0),
+        m_Opacity(-1.0),
         m_Selectable(true),
         m_Selected(false),
         m_Visibility(true),
         m_Dragable(true)
     {
-        m_Color = Vector3d(-1, -1, -1);
+        m_Color[0] = m_Color[1] = m_Color[2] = -1.0;
+        m_Position = Vector3d::Zero();
+        m_Orientation = Vector3d::Zero();
+        m_Scale = Vector3d::Ones();
     }
 
     ~PuppetData() {
         // No manual Delete needed for smart pointers
     }
 
-    Puppet *m_Puppet;
     // members //
     vtkSmartPointer<vtkRendererCollection> m_Renderers;
-    vtkSmartPointer<vtkProp3D>             m_Prop;
+    vtkSmartPointer<vtkAssembly>       m_Assembly;
 
     vtkSmartPointer<vtkOutlineSource>      m_OutlineSource;
     vtkSmartPointer<vtkActor>              m_OutlineActor;
@@ -115,146 +118,91 @@ public:
     bool m_ShowBoundingBox;
     bool m_ShowScaleMeasures;
     int m_Representation;
-    Vector3d m_Color;
+    double m_Color[3];
     double m_Opacity;
 
     bool m_Selectable;
     bool m_Selected;
     bool m_Visibility;
     bool m_Dragable;
-
+    Vector3d m_Position;
-    // 
+    Vector3d m_Orientation;
-    TRS m_Transform;
+    Vector3d m_Scale;
 
     void ApplyAppearance(vtkProp *p) {
-        if (!p) return;
         p->SetVisibility(m_Visibility);
         p->SetPickable(m_Selectable);
         p->SetDragable(m_Dragable);
 
         vtkActor *actor = vtkActor::SafeDownCast(p);
         if (actor) {
-            if (m_Representation != -1 && m_Representation != Puppet::Volume) {
+            if (m_Representation != -1) {
                 if (m_Representation == Puppet::SurfaceWithEdges) {
                     actor->GetProperty()->SetRepresentation(VTK_SURFACE);
                     actor->GetProperty()->SetEdgeVisibility(1);
-                } else if (m_Representation != Puppet::Outline && m_Representation != Puppet::Slice) {
+                } else {
                     actor->GetProperty()->SetRepresentation(m_Representation);
                     actor->GetProperty()->SetEdgeVisibility(0);
                 }
             }
-            if (m_Color.x() != -1.0) {
+            if (m_Color[0] != -1.0) {
-                double c[3] = {m_Color.x(), m_Color.y(), m_Color.z()};
+                actor->GetProperty()->SetColor(m_Color);
-                actor->GetProperty()->SetColor(c);
             }
 
             if (m_Opacity != -1.0) {
                 actor->GetProperty()->SetOpacity(m_Opacity);
             }
-        } else if (vtkAssembly *asm_p = vtkAssembly::SafeDownCast(p)) {
-            // Recursively apply to parts of the assembly
-            vtkProp3DCollection *parts = asm_p->GetParts();
-            if (parts) {
-                parts->InitTraversal();
-                for (int i = 0; i < parts->GetNumberOfItems(); ++i) {
-                    this->ApplyAppearance(parts->GetNextProp3D());
-                }
-            }
-        }
         }
 
-    void ApplyTransform(vtkProp3D* p3d) {
+        // Handle transformation if it's a Prop3D
-        if (p3d) {
+        if (auto* p3d = vtkProp3D::SafeDownCast(p)) {
-            p3d->SetUserMatrix(nullptr);
+            // NOTE: Usually managed by Puppet::Update from model, but here for direct prop manipulation
-            p3d->SetPosition(m_Transform.position.x(), m_Transform.position.y(), m_Transform.position.z());
+            // p3d->SetPosition(m_Position.data());
-            
+            // p3d->SetOrientation(m_Orientation.data());
-            // Convert Model Radians to VTK Degrees
+            // p3d->SetScale(m_Scale.data());
-            p3d->SetOrientation(m_Transform.rotation.x() / CLHEP::degree, 
-                               m_Transform.rotation.y() / CLHEP::degree, 
-                               m_Transform.rotation.z() / CLHEP::degree);
-            
-            p3d->SetScale(m_Transform.scaling.x(), m_Transform.scaling.y(), m_Transform.scaling.z());
         }
     }
 
     void UpdateHighlight() {
         if (m_Selected) {
+            if (!m_HighlightActor) {
+                vtkSmartPointer<vtkFeatureEdges> edges = vtkSmartPointer<vtkFeatureEdges>::New();
+                edges->BoundaryEdgesOn();
+                edges->FeatureEdgesOn();
+                edges->SetFeatureAngle(30);
+                edges->NonManifoldEdgesOn();
+                edges->ManifoldEdgesOff();
+
                 // Find first polydata in assembly to highlight
-            vtkPolyData* polydata = nullptr;
+                vtkPropCollection *parts = m_Assembly->GetParts();
-            if (vtkActor *actor = vtkActor::SafeDownCast(m_Prop)) {
-                if (actor->GetMapper()) {
-                    polydata = vtkPolyData::SafeDownCast(actor->GetMapper()->GetDataSetInput());
-                }
-            } else if (vtkAssembly *asm_p = vtkAssembly::SafeDownCast(m_Prop)) {
-                vtkPropCollection *parts = asm_p->GetParts();
-                if (parts) {
                 parts->InitTraversal();
                 for (int i = 0; i < parts->GetNumberOfItems(); ++i) {
-                        vtkActor *a = vtkActor::SafeDownCast(parts->GetNextProp());
+                    vtkActor *actor = vtkActor::SafeDownCast(parts->GetNextProp());
-                        if (a && a->GetMapper()) {
+                    if (actor && actor->GetMapper() && actor->GetMapper()->GetDataSetInput()) {
-                            polydata = vtkPolyData::SafeDownCast(a->GetMapper()->GetDataSetInput());
+                        edges->SetInputData(vtkPolyData::SafeDownCast(actor->GetMapper()->GetDataSetInput()));
-                            if (polydata) break;
+                        break;
                     }
                 }
-                }
-            }
-
-            if (!polydata) {
-                if (m_HighlightActor) {
-                    m_Renderers->InitTraversal();
-                    for (int i = 0; i < m_Renderers->GetNumberOfItems(); ++i) {
-                        m_Renderers->GetNextItem()->RemoveActor(m_HighlightActor);
-                    }
-                    m_HighlightActor = nullptr;
-                }
-                return;
-            }
-
-            if (!m_HighlightActor) {
-                vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
-                double bounds[6];
-                polydata->GetBounds(bounds);
-                // Add a small padding to prevent z-fighting
-                double maxDim = std::max({bounds[1]-bounds[0], bounds[3]-bounds[2], bounds[5]-bounds[4]});
-                double pad = maxDim * 0.02;
-                if(pad < 1e-4) pad = 0.05;
-                cube->SetBounds(bounds[0]-pad, bounds[1]+pad,
-                                bounds[2]-pad, bounds[3]+pad,
-                                bounds[4]-pad, bounds[5]+pad);
 
                 m_HighlightActor = vtkSmartPointer<vtkActor>::New();
                 vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-                mapper->SetInputConnection(cube->GetOutputPort());
+                mapper->SetInputConnection(edges->GetOutputPort());
                 m_HighlightActor->SetMapper(mapper);
-                m_HighlightActor->GetProperty()->SetRepresentationToWireframe();
+                m_HighlightActor->GetProperty()->SetColor(1.0, 0.5, 0.0); // Orange
-                m_HighlightActor->GetProperty()->SetColor(1.0, 0.0, 0.0); // Red
                 m_HighlightActor->GetProperty()->SetLineWidth(2.0);
                 m_HighlightActor->GetProperty()->SetLighting(0);
-            } else {
-                if (auto* mapper = vtkPolyDataMapper::SafeDownCast(m_HighlightActor->GetMapper())) {
-                    if (auto* cube = vtkCubeSource::SafeDownCast(mapper->GetInputAlgorithm())) {
-                        double bounds[6];
-                        polydata->GetBounds(bounds);
-                        double maxDim = std::max({bounds[1]-bounds[0], bounds[3]-bounds[2], bounds[5]-bounds[4]});
-                        double pad = maxDim * 0.02;
-                        if(pad < 1e-4) pad = 0.05;
-                        cube->SetBounds(bounds[0]-pad, bounds[1]+pad,
-                                        bounds[2]-pad, bounds[3]+pad,
-                                        bounds[4]-pad, bounds[5]+pad);
-                        cube->Modified();
-                    }
-                }
             }
 
-            // Update highlight matrix from the model world matrix
+            // Update highlight matrix from the root prop
-            if (m_Puppet) {
+            vtkProp3D* root = nullptr;
-                if (auto* content = m_Puppet->GetContent()) {
+            if (m_Assembly->GetParts()->GetNumberOfItems() == 1) {
-                    if (auto* tr = dynamic_cast<uLib::TRS*>(content)) {
+                root = vtkProp3D::SafeDownCast(m_Assembly->GetParts()->GetLastProp());
-                        vtkNew<vtkMatrix4x4> vwm;
+            } else {
-                        Matrix4fToVtk(tr->GetWorldMatrix(), vwm);
+                root = m_Assembly;
-                        m_HighlightActor->SetUserMatrix(vwm);
-                    }
             }
+
+            if (root) {
+                m_HighlightActor->SetUserMatrix(root->GetMatrix());
             }
 
             m_Renderers->InitTraversal();
@@ -278,16 +226,7 @@ public:
 
 
 
-
+Puppet::Puppet() : Object(), pd(new PuppetData) { 
-
-
-
-
-
-
-
-
-Puppet::Puppet() : Object(), pd(new PuppetData(this)) { 
     ULIB_ACTIVATE_DISPLAY_PROPERTIES;
     for (auto* p : this->GetDisplayProperties()) {
         uLib::Object::connect(p, &uLib::PropertyBase::Updated, this, &Puppet::Update);
@@ -301,38 +240,33 @@ Puppet::~Puppet()
 
 vtkProp *Puppet::GetProp()
 {
-    return pd->m_Prop;
+    if (pd->m_Assembly->GetParts()->GetNumberOfItems() == 1)
-}
+        return pd->m_Assembly->GetParts()->GetLastProp();
-
+    else 
-vtkProp3D *Puppet::GetProxyProp()
+        return pd->m_Assembly;
-{
-    // The handler should manipulate the highlight actor if it exists
-    if (pd->m_HighlightActor) {
-        return pd->m_HighlightActor;
-    }
-    return vtkProp3D::SafeDownCast(this->GetProp());
 }
 
 void Puppet::SetProp(vtkProp *prop)
 {
     if(prop) {
         prop->SetPickable(pd->m_Selectable);
-        pd->m_Prop = vtkProp3D::SafeDownCast(prop);
+        if (auto* p3d = vtkProp3D::SafeDownCast(prop)) {
+            pd->m_Assembly->AddPart(p3d);
+        }
         pd->ApplyAppearance(prop);
 
         // For the first actor added, seed the tracked display values from the VTK
         // actor's current state so the display properties panel shows meaningful
         // initial values instead of the -1 "not-overriding" sentinels.
+        if (pd->m_Assembly->GetParts()->GetNumberOfItems() == 1) {
             if (auto* actor = vtkActor::SafeDownCast(prop)) {
                 vtkProperty* vp = actor->GetProperty();
                 if (pd->m_Representation < 0)
                     pd->m_Representation = vp->GetRepresentation();
                 if (pd->m_Opacity < 0)
                     pd->m_Opacity = vp->GetOpacity();
-            if (pd->m_Color.x() < 0) {
+                if (pd->m_Color[0] < 0)
-                double c[3];
+                    vp->GetColor(pd->m_Color);
-                vp->GetColor(c);
-                pd->m_Color = Vector3d(c[0], c[1], c[2]);
             }
         }
     }
@@ -343,31 +277,15 @@ void Puppet::RemoveProp(vtkProp *prop)
     // TODO
 }
 
-void Puppet::ApplyAppearance(vtkProp* prop)
-{
-    pd->ApplyAppearance(prop);
-}
-
-void Puppet::ApplyTransform(vtkProp3D* p3d)
-{
-    pd->ApplyTransform(p3d);
-}
-
 
 vtkPropCollection *Puppet::GetParts()
 {
-    if (auto* asm_p = vtkAssembly::SafeDownCast(pd->m_Prop)) {
+    return pd->m_Assembly->GetParts();
-        return asm_p->GetParts();
-    }
-    return nullptr;
 }
 
 vtkPropCollection *Puppet::GetProps()
 {
-    if (auto* asm_p = vtkAssembly::SafeDownCast(pd->m_Prop)) {
+    return pd->m_Assembly->GetParts();
-        return asm_p->GetParts();
-    }
-    return nullptr;
 }
 
 void Puppet::ConnectRenderer(vtkRenderer *renderer)
@@ -421,8 +339,7 @@ vtkRendererCollection *Puppet::GetRenderers() const
 void Puppet::PrintSelf(std::ostream &o) const
 {
     o << "Props Assembly: \n";
-    if (pd->m_Prop)
+    pd->m_Assembly->PrintSelf(o,vtkIndent(1));
-        pd->m_Prop->PrintSelf(o,vtkIndent(1));
 
     o << "Connected Renderers: \n";
     pd->m_Renderers->PrintSelf(o,vtkIndent(1));
@@ -442,11 +359,9 @@ void Puppet::ShowBoundingBox(bool show)
             pd->m_OutlineActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
         }
 
-        if (pd->m_Prop) {
+        double* bounds = pd->m_Assembly->GetBounds();
-            double* bounds = pd->m_Prop->GetBounds();
         pd->m_OutlineSource->SetBounds(bounds);
         pd->m_OutlineSource->Update();
-        }
 
         pd->m_Renderers->InitTraversal();
         for (int i = 0; i < pd->m_Renderers->GetNumberOfItems(); ++i) {
@@ -476,10 +391,8 @@ void Puppet::ShowScaleMeasures(bool show)
             pd->m_CubeAxesActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
         }
 
-        if (pd->m_Prop) {
+        double* bounds = pd->m_Assembly->GetBounds();
-            double* bounds = pd->m_Prop->GetBounds();
         pd->m_CubeAxesActor->SetBounds(bounds);
-        }
 
         pd->m_Renderers->InitTraversal();
         for (int i = 0; i < pd->m_Renderers->GetNumberOfItems(); ++i) {
@@ -501,7 +414,12 @@ void Puppet::ShowScaleMeasures(bool show)
 void Puppet::SetRepresentation(Representation mode)
 {
     pd->m_Representation = static_cast<int>(mode);
-    pd->ApplyAppearance(pd->m_Prop);
+
+    vtkProp3DCollection *props = pd->m_Assembly->GetParts();
+    props->InitTraversal();
+    for (int i = 0; i < props->GetNumberOfItems(); ++i) {
+        pd->ApplyAppearance(props->GetNextProp3D());
+    }
 }
 
 void Puppet::SetRepresentation(const char *mode)
@@ -521,13 +439,23 @@ void Puppet::SetColor(double r, double g, double b)
     pd->m_Color[0] = r;
     pd->m_Color[1] = g;
     pd->m_Color[2] = b;
-    pd->ApplyAppearance(pd->m_Prop);
+
+    vtkProp3DCollection *props = pd->m_Assembly->GetParts();
+    props->InitTraversal();
+    for (int i = 0; i < props->GetNumberOfItems(); ++i) {
+        pd->ApplyAppearance(props->GetNextProp3D());
+    }
 }
 
 void Puppet::SetOpacity(double alpha)
 {
     pd->m_Opacity = alpha;
-    pd->ApplyAppearance(pd->m_Prop);
+
+    vtkProp3DCollection *props = pd->m_Assembly->GetParts();
+    props->InitTraversal();
+    for (int i = 0; i < props->GetNumberOfItems(); ++i) {
+        pd->ApplyAppearance(props->GetNextProp3D());
+    }
 }
 
 
@@ -539,7 +467,11 @@ void Puppet::SetOpacity(double alpha)
 void Puppet::SetSelectable(bool selectable)
 {
     pd->m_Selectable = selectable;
-    pd->ApplyAppearance(pd->m_Prop);
+    vtkProp3DCollection *props = pd->m_Assembly->GetParts();
+    props->InitTraversal();
+    for (int i = 0; i < props->GetNumberOfItems(); ++i) {
+        props->GetNextProp3D()->SetPickable(selectable);
+    }
 }
 
 bool Puppet::IsSelectable() const
@@ -562,28 +494,38 @@ bool Puppet::IsSelected() const
 
 void Puppet::Update()
 {
-    // Derived classes should have updated the transform if they override Update()
+    vtkProp* root = this->GetProp();
-    // or we can apply base transform if it's default:
+    if (root) {
-    // pd->ApplyTransform(pd->m_Prop);
+        pd->ApplyAppearance(root);
         
-    pd->ApplyAppearance(pd->m_Prop);
+        // Apply transformation if it's a Prop3D
+        if (auto* p3d = vtkProp3D::SafeDownCast(root)) {
+             p3d->SetPosition(pd->m_Position.data());
+             p3d->SetOrientation(pd->m_Orientation.data());
+             p3d->SetScale(pd->m_Scale.data());
+        }
+    }
+
+    vtkProp3DCollection *props = pd->m_Assembly->GetParts();
+    props->InitTraversal();
+    for (int i = 0; i < props->GetNumberOfItems(); ++i) {
+        pd->ApplyAppearance(props->GetNextProp3D());
+    }
 
     if (pd->m_Selected) {
         pd->UpdateHighlight();
     }
     
-    if (pd->m_Prop) {
     if (pd->m_ShowBoundingBox) {
-            double* bounds = pd->m_Prop->GetBounds();
+        double* bounds = pd->m_Assembly->GetBounds();
         pd->m_OutlineSource->SetBounds(bounds);
         pd->m_OutlineSource->Update();
     }
     
     if (pd->m_ShowScaleMeasures) {
-            double* bounds = pd->m_Prop->GetBounds();
+        double* bounds = pd->m_Assembly->GetBounds();
         pd->m_CubeAxesActor->SetBounds(bounds);
     }
-    }
 
     // Notify that the object has been updated (important for UI refresh)
     this->Object::Updated();
@@ -597,23 +539,42 @@ void Puppet::Update()
     }
 }
 
+void Puppet::SyncFromVtk()
+{
+    vtkProp* root = this->GetProp();
+    if (auto* p3d = vtkProp3D::SafeDownCast(root)) {
+        double pos[3], ori[3], scale[3];
+        p3d->GetPosition(pos);
+        p3d->GetOrientation(ori);
+        p3d->GetScale(scale);
+
+        // Update properties
+        for (int i=0; i<3; ++i) {
+            pd->m_Position(i) = pos[i];
+            pd->m_Orientation(i) = ori[i];
+            pd->m_Scale(i) = scale[i];
+        }
+        
+        // Get the properties from the object
+        if (auto* propPos = this->GetProperty("Position")) propPos->Updated();
+        if (auto* propOri = this->GetProperty("Orientation")) propOri->Updated();
+        if (auto* propScale = this->GetProperty("Scale")) propScale->Updated();
+        
+        this->Object::Updated();
+    }
+}
 
 void Puppet::ConnectInteractor(vtkRenderWindowInteractor *interactor)
 {
 }
 
-
-
-
-// ------------------------------------------------------ //
-// SERIALIZE DISPLAY PROPERTIES
-
-
 struct TransformProxy {
     PuppetData* pd;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int version) {
-        ar & boost::serialization::make_nvp("Transform", pd->m_Transform);
+        ar & boost::serialization::make_hrp("Position", pd->m_Position, "mm");
+        ar & boost::serialization::make_hrp("Orientation", pd->m_Orientation, "deg");
+        ar & boost::serialization::make_hrp("Scale", pd->m_Scale, "");
     }
 };
 
@@ -621,15 +582,14 @@ struct AppearanceProxy {
     PuppetData* pd;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int version) {
-        ar & boost::serialization::make_hrp("Color", pd->m_Color, "color");
+        ar & boost::serialization::make_hrp("ColorR", pd->m_Color[0]);
-        ar & boost::serialization::make_hrp("Opacity", pd->m_Opacity).range(0.0, 1.0).set_default(1.0);
+        ar & boost::serialization::make_hrp("ColorG", pd->m_Color[1]);
-        ar & boost::serialization::make_hrp_enum("Representation", 
+        ar & boost::serialization::make_hrp("ColorB", pd->m_Color[2]);
-            pd->m_Representation, {"Points", "Wireframe", "Surface", "SurfaceWithEdges", "Volume", "Outline", "Slice"});
+        ar & boost::serialization::make_hrp("Opacity", pd->m_Opacity);
+        ar & boost::serialization::make_hrp_enum("Representation", pd->m_Representation, {"Points", "Wireframe", "Surface", "SurfaceWithEdges", "Volume", "Outline", "Slice"});
         ar & boost::serialization::make_hrp("Visibility", pd->m_Visibility);
         ar & boost::serialization::make_hrp("Pickable", pd->m_Selectable);
         ar & boost::serialization::make_hrp("Dragable", pd->m_Dragable);
-        ar & boost::serialization::make_hrp("ShowBoundingBox", pd->m_ShowBoundingBox);
-        ar & boost::serialization::make_hrp("ShowScaleMeasures", pd->m_ShowScaleMeasures);
     }
 };
 
@@ -641,6 +601,13 @@ void Puppet::serialize_display(Archive::display_properties_archive & ar, const u
     ar & boost::serialization::make_nvp("Transform", transform);
 }
 
+void Puppet::serialize(Archive::xml_oarchive & ar, const unsigned int v) { }
+void Puppet::serialize(Archive::xml_iarchive & ar, const unsigned int v) { }
+void Puppet::serialize(Archive::text_oarchive & ar, const unsigned int v) { }
+void Puppet::serialize(Archive::text_iarchive & ar, const unsigned int v) { }
+void Puppet::serialize(Archive::hrt_oarchive & ar, const unsigned int v) { }
+void Puppet::serialize(Archive::hrt_iarchive & ar, const unsigned int v) { }
+void Puppet::serialize(Archive::log_archive & ar, const unsigned int v) { }
 
 } // namespace Vtk
 } // namespace uLib

src/Vtk/uLibVtkInterface.h

@@ -26,19 +26,18 @@
 #ifndef ULIBVTKINTERFACE_H
 #define ULIBVTKINTERFACE_H
 
-#include "Core/Monitor.h"
-#include "Core/Object.h"
-#include "Core/Property.h"
-#include <boost/mpl/bool.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/type_traits/is_class.hpp>
 #include <iomanip>
 #include <ostream>
 #include <vector>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/serialization/serialization.hpp>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Monitor.h"
 
 // vtk classes forward declaration //
 class vtkProp;
-class vtkProp3D;
 class vtkPolyData;
 class vtkPropCollection;
 class vtkRenderer;
@@ -46,27 +45,20 @@ class vtkRendererCollection;
 class vtkRenderWindowInteractor;
 
 namespace uLib {
-namespace Archive {
+  namespace Archive { class display_properties_archive; }
-class display_properties_archive;
+  namespace Vtk { class Puppet; class Viewer; }
 }
-namespace Vtk {
-class Puppet;
-class Viewer;
-} // namespace Vtk
-} // namespace uLib
 
 namespace uLib {
 namespace Vtk {
 
 class Puppet : public uLib::Object {
-
+  uLibTypeMacro(Puppet, uLib::Object)
-uLibTypeMacro(Puppet, uLib::Object)
+public:
-
+  Puppet();
-    public : Puppet();
   virtual ~Puppet();
 
   virtual vtkProp *GetProp();
-  virtual vtkProp3D *GetProxyProp();
 
   virtual vtkPropCollection *GetParts();
 
@@ -92,31 +84,10 @@ uLibTypeMacro(Puppet, uLib::Object)
   void SetSelected(bool selected = true);
   bool IsSelected() const;
 
-  /**
-   * @brief Synchronizes the VTK representation with the internal state and properties.
-   *
-   * This method should be called whenever the underlying model or display properties
-   * are modified to ensure the visual representation in VTK is consistent.
-   */
   virtual void Update();
+  virtual void SyncFromVtk();
 
-  /**
+  enum Representation { Points = 0, Wireframe = 1, Surface = 2, SurfaceWithEdges = 3, Volume = 4, Outline = 5, Slice = 6 };
-   * @brief Synchronizes the internal state and properties from the VTK representation.
-   *
-   * This method should be called when the VTK representation has been modified
-   * (e.g., via a gizmo) and the changes need to be pushed back to the model.
-   */
-  virtual void SyncFromVtk() {}
-
-  enum Representation {
-    Points = 0,
-    Wireframe = 1,
-    Surface = 2,
-    SurfaceWithEdges = 3,
-    Volume = 4,
-    Outline = 5,
-    Slice = 6
-  };
   void SetRepresentation(Representation mode);
   void SetRepresentation(const char *mode);
 
@@ -127,15 +98,18 @@ uLibTypeMacro(Puppet, uLib::Object)
 
   vtkRendererCollection *GetRenderers() const;
 
-  const std::vector<uLib::PropertyBase *> &GetDisplayProperties() const {
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) override;
-    return m_DisplayProperties;
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) override;
-  }
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) override;
-  void RegisterDisplayProperty(uLib::PropertyBase *prop) {
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) override;
-    m_DisplayProperties.push_back(prop);
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) override;
-  }
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) override;
+  virtual void serialize(Archive::log_archive & ar, const unsigned int version) override;
 
-  virtual void serialize_display(uLib::Archive::display_properties_archive &ar,
+  const std::vector<uLib::PropertyBase*>& GetDisplayProperties() const { return m_DisplayProperties; }
-                                 const unsigned int version = 0);
+  void RegisterDisplayProperty(uLib::PropertyBase* prop) { m_DisplayProperties.push_back(prop); }
+
+  virtual void serialize_display(uLib::Archive::display_properties_archive & ar, const unsigned int version = 0);
 
   virtual void ConnectInteractor(class vtkRenderWindowInteractor *interactor);
 
@@ -147,15 +121,12 @@ protected:
 
   void RemoveProp(vtkProp *prop);
 
-  void ApplyAppearance(vtkProp *prop);
+  std::vector<uLib::PropertyBase*> m_DisplayProperties;
-  void ApplyTransform(vtkProp3D *p3d);
-
-  std::vector<uLib::PropertyBase *> m_DisplayProperties;
   mutable uLib::RecursiveMutex m_UpdateMutex;
 
 private:
-  Puppet(const Puppet &) = delete;
+  Puppet(const Puppet&) = delete;
-  Puppet &operator=(const Puppet &) = delete;
+  Puppet& operator=(const Puppet&) = delete;
 
   friend class PuppetData;
   class PuppetData *pd;
@@ -164,6 +135,15 @@ private:
 } // namespace Vtk
 } // namespace uLib
 
+
+
+
+
+
+
+
+
+
 // -------------------------------------------------------------------------- //
 // DISPLAY PROPERTIES SERIALIZE 
 // -------------------------------------------------------------------------- //
@@ -172,97 +152,79 @@ namespace uLib {
 namespace Archive {
 
 /**
- * @brief Specialized archive for registering display-only properties in
+ * @brief Specialized archive for registering display-only properties in Puppets.
- * Puppets.
  */
-class display_properties_archive
+class display_properties_archive : public boost::archive::detail::common_oarchive<display_properties_archive> {
-    : public boost::archive::detail::common_oarchive<
-          display_properties_archive> {
 public:
-  display_properties_archive(Vtk::Puppet *puppet)
+    display_properties_archive(Vtk::Puppet* puppet) : 
-      : boost::archive::detail::common_oarchive<display_properties_archive>(
+        boost::archive::detail::common_oarchive<display_properties_archive>(boost::archive::no_header),
-            boost::archive::no_header),
         m_Puppet(puppet) {}
     
     std::string GetCurrentGroup() const {
         std::string group;
-    for (const auto &g : m_GroupStack) {
+        for (const auto& g : m_GroupStack) {
-      if (!group.empty())
+            if (!group.empty()) group += ".";
-        group += ".";
             group += g;
         }
         return group;
     }
 
-  template <class T> void save_override(const boost::serialization::hrp<T> &t) {
+    template<class T>
+    void save_override(const boost::serialization::hrp<T> &t) {
         if (m_Puppet) {
-      uLib::Property<T> *p = new uLib::Property<T>(
+            uLib::Property<T>* p = new uLib::Property<T>(m_Puppet, t.name(), &const_cast<boost::serialization::hrp<T>&>(t).value(), t.units() ? t.units() : "", GetCurrentGroup());
-          m_Puppet, 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());
-
             m_Puppet->RegisterDisplayProperty(p);
-      Vtk::Puppet *puppet = m_Puppet;
+            Vtk::Puppet* puppet = m_Puppet;
-      uLib::Object::connect(p, &uLib::PropertyBase::Updated,
+            uLib::Object::connect(p, &uLib::PropertyBase::Updated, [puppet](){ puppet->Update(); });
-                            [puppet]() { puppet->Update(); });
         }
     }
 
-  template <class T>
+    template<class T>
     void save_override(const boost::serialization::hrp_enum<T> &t) {
         if (m_Puppet) {
-      uLib::EnumProperty *p = new uLib::EnumProperty(
+            uLib::EnumProperty* p = new uLib::EnumProperty(m_Puppet, t.name(), (int*)&const_cast<boost::serialization::hrp_enum<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
-          m_Puppet, t.name(),
-          (int *)&const_cast<boost::serialization::hrp_enum<T> &>(t).value(),
-          t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
             m_Puppet->RegisterDisplayProperty(p);
-      Vtk::Puppet *puppet = m_Puppet;
+            Vtk::Puppet* puppet = m_Puppet;
-      uLib::Object::connect(p, &uLib::PropertyBase::Updated,
+            uLib::Object::connect(p, &uLib::PropertyBase::Updated, [puppet](){ puppet->Update(); });
-                            [puppet]() { puppet->Update(); });
         }
     }
 
-  template <class T> void save_override(const boost::serialization::nvp<T> &t) {
+    template<class T> void save_override(const boost::serialization::nvp<T> &t) {
-    if (t.name())
+        if (t.name()) m_GroupStack.push_back(t.name());
-      m_GroupStack.push_back(t.name());
         this->save_helper(t.const_value(), typename boost::is_class<T>::type());
-    if (t.name())
+        if (t.name()) m_GroupStack.pop_back();
-      m_GroupStack.pop_back();
     }
 
     // Recursion for nested classes, ignore primitives
-  template <class T> void save_override(const T &t) {
+    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_) {
+    template<class T>
-    boost::serialization::serialize_adl(*this, const_cast<T &>(t), 0);
+    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_) {}
+    template<class T>
+    void save_helper(const T &t, boost::mpl::false_) {}
 
-  void save_override(const boost::archive::object_id_type &t) {}
+    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::object_reference_type & t) {}
-  void save_override(const boost::archive::version_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_type & t) {}
-  void save_override(const boost::archive::class_id_optional_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_id_reference_type & t) {}
-  void save_override(const boost::archive::class_name_type &t) {}
+    void save_override(const boost::archive::class_name_type & t) {}
-  void save_override(const boost::archive::tracking_type &t) {}
+    void save_override(const boost::archive::tracking_type & t) {}
 
 private:
-  Vtk::Puppet *m_Puppet;
+    Vtk::Puppet* m_Puppet;
     std::vector<std::string> m_GroupStack;
 };
 
 } // namespace Archive
 
-// This macro MUST be defined after both Puppet and display_properties_archive
+// This macro MUST be defined after both Puppet and display_properties_archive are fully defined.
-// are fully defined.
 #define ULIB_ACTIVATE_DISPLAY_PROPERTIES \
     { \
         uLib::Archive::display_properties_archive dar(this); \

src/Vtk/uLibVtkViewer.cpp

@@ -72,7 +72,6 @@ struct ViewerData {
   vtkRenderWindow *m_RenderWindow;
   vtkSmartPointer<vtkRenderWindowInteractor> m_Interactor;
   vtkSmartPointer<vtkButtonWidget> m_GridButton;
-  vtkSmartPointer<vtkButtonWidget> m_ProjButton;
 
   ViewerData() : m_RenderWindow(vtkRenderWindow::New()) {}
   ~ViewerData() {
@@ -98,11 +97,6 @@ Viewer::~Viewer() {
       dv->m_GridButton->SetInteractor(nullptr);
       dv->m_GridButton = nullptr;
   }
-  if (dv->m_ProjButton) {
-      dv->m_ProjButton->Off();
-      dv->m_ProjButton->SetInteractor(nullptr);
-      dv->m_ProjButton = nullptr;
-  }
   if (this->GetRenderWindow()) {
       this->GetRenderWindow()->RemoveAllObservers();
   }
@@ -129,7 +123,6 @@ void Viewer::InstallPipe() {
   // Setup native grid button
   if (!std::getenv("CTEST_PROJECT_NAME")) {
       SetupGridButton();
-      SetupProjButton();
   }
 
   // BUT we want to override the style with our custom NoSpin version
@@ -245,88 +238,6 @@ void Viewer::UpdateGridButtonPosition() {
   rep->PlaceWidget(bds);
 }
 
-void Viewer::SetupProjButton() {
-  if (!dv->m_RenderWindow || !dv->m_RenderWindow->GetInteractor()) return;
-
-  vtkNew<vtkImageCanvasSource2D> canvas;
-  canvas->SetScalarTypeToUnsignedChar();
-  canvas->SetNumberOfScalarComponents(4);
-  canvas->SetExtent(0, 63, 0, 63, 0, 0);
-
-  // State 0: Perspective (gray trapezoid-like lines)
-  canvas->SetDrawColor(0, 0, 0, 0);
-  canvas->FillBox(0, 63, 0, 63);
-  canvas->SetDrawColor(120, 120, 120, 255);
-  canvas->DrawSegment(16, 16, 48, 16);
-  canvas->DrawSegment(48, 16, 56, 48);
-  canvas->DrawSegment(56, 48, 8,  48);
-  canvas->DrawSegment(8,  48, 16, 16);
-  canvas->Update();
-
-  vtkNew<vtkImageData> imgPersp;
-  imgPersp->DeepCopy(canvas->GetOutput());
-
-  // State 1: Orthographic (white rectangle)
-  canvas->SetDrawColor(0, 0, 0, 0);
-  canvas->FillBox(0, 63, 0, 63);
-  canvas->SetDrawColor(255, 255, 255, 255);
-  canvas->DrawSegment(12, 16, 52, 16);
-  canvas->DrawSegment(52, 16, 52, 48);
-  canvas->DrawSegment(52, 48, 12, 48);
-  canvas->DrawSegment(12, 48, 12, 16);
-  canvas->Update();
-
-  vtkNew<vtkImageData> imgOrtho;
-  imgOrtho->DeepCopy(canvas->GetOutput());
-
-  vtkNew<vtkTexturedButtonRepresentation2D> rep;
-  rep->SetNumberOfStates(2);
-  rep->SetButtonTexture(0, imgPersp);
-  rep->SetButtonTexture(1, imgOrtho);
-
-  dv->m_ProjButton = vtkSmartPointer<vtkButtonWidget>::New();
-  dv->m_ProjButton->SetInteractor(dv->m_RenderWindow->GetInteractor());
-  dv->m_ProjButton->SetRepresentation(rep);
-
-  UpdateProjButtonPosition();
-
-  vtkNew<vtkCallbackCommand> resizeCallback;
-  resizeCallback->SetClientData(this);
-  resizeCallback->SetCallback([](vtkObject*, unsigned long, void* clientdata, void*){
-      static_cast<Viewer*>(clientdata)->UpdateProjButtonPosition();
-  });
-  dv->m_RenderWindow->AddObserver(vtkCommand::ModifiedEvent, resizeCallback);
-
-  vtkNew<vtkCallbackCommand> stateCallback;
-  stateCallback->SetClientData(this);
-  stateCallback->SetCallback([](vtkObject* caller, unsigned long, void* clientdata, void*){
-      auto* btn = vtkButtonWidget::SafeDownCast(caller);
-      auto* v = static_cast<Viewer*>(clientdata);
-      auto* r = vtkTexturedButtonRepresentation2D::SafeDownCast(btn->GetRepresentation());
-      v->SetParallelProjection(r->GetState() == 1);
-  });
-  dv->m_ProjButton->AddObserver(vtkCommand::StateChangedEvent, stateCallback);
-  dv->m_ProjButton->On();
-
-  rep->SetState(GetParallelProjection() ? 1 : 0);
-}
-
-void Viewer::UpdateProjButtonPosition() {
-  if (!dv->m_ProjButton || !dv->m_RenderWindow) return;
-  auto* rep = vtkTexturedButtonRepresentation2D::SafeDownCast(dv->m_ProjButton->GetRepresentation());
-  if (!rep) return;
-
-  int *sz = dv->m_RenderWindow->GetSize();
-  if (sz[0] == 0 || sz[1] == 0) return;
-
-  int margin_right = 23;
-  int margin_top = 220; // below the grid button (170 + 50)
-  int btnSz = 100;
-  double bds[6] = { (double)sz[0] - btnSz - margin_right, (double)sz[0] - margin_right,
-                    (double)sz[1] - margin_top  - btnSz/2.0, (double)sz[1] - margin_top + btnSz/2.0, 0, 0 };
-  rep->PlaceWidget(bds);
-}
-
 void Viewer::Start() { 
   if (std::getenv("CTEST_PROJECT_NAME")) return;
   dv->m_RenderWindow->GetInteractor()->Start();