algorithm chain for ram-vram

check if algorithm could be run on cuda
algorithm on filters
2026-03-28 08:22:14 +00:00 · 2026-03-27 16:42:04 +00:00 · 2026-03-27 02:45:40 +00:00 · 2026-03-27 02:29:56 +00:00
58 changed files with 1716 additions and 1275 deletions
--- a/app/gcompose/src/ContextModel.cpp
+++ b/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();
-        if (parentCtx && row < (int)parentCtx->GetCount()) {
+        uLib::ObjectsContext* parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
+        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 = 
-        [&findParent](uLib::Object* current, uLib::Object* target) -> uLib::Object* {
-        uLib::ObjectsContext* ctx = current->GetChildren();
-        if (ctx) {
-            for (const auto& obj : ctx->GetObjects()) {
-                if (obj == target) return current;
-                if (auto p = findParent(obj, target)) return p;
+    std::function<uLib::ObjectsContext*(uLib::ObjectsContext*, uLib::Object*)> findParent = 
+        [&findParent](uLib::ObjectsContext* ctx, uLib::Object* target) -> uLib::ObjectsContext* {
+        for (const auto& obj : ctx->GetObjects()) {
+            if (obj == target) return ctx;
+            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);
-    if (!parentObj || parentObj == m_rootContext) {
+    uLib::ObjectsContext* parentCtx = findParent(m_rootContext, childObj);
+    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.
-    uLib::Object* grandParentObj = findParent(m_rootContext, parentObj);
-    uLib::ObjectsContext* grandParentCtx = grandParentObj ? grandParentObj->GetChildren() : m_rootContext;
+    // Now need to find the row of parentCtx in its own parent Context.
+    uLib::ObjectsContext* grandParentCtx = findParent(m_rootContext, parentCtx);
+    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()) {
-        return (int)parentCtx->GetCount();
+    if (auto parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj)) {
+        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;
-    
-    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;
+    if (!index.isValid()) return Qt::NoItemFlags;
+    return Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 }

 bool ContextModel::setData(const QModelIndex& index, const QVariant& value, int role) {
--- a/app/gcompose/src/ContextModel.h
+++ b/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
--- a/app/gcompose/src/ContextPanel.cpp
+++ b/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);
--- a/app/gcompose/src/PropertyWidgets.cpp
+++ b/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()) {
@@ -49,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;
@@ -105,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);
    }
@@ -207,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>::PropertyChanged, [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>::PropertyChanged, [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);
@@ -432,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());
--- a/app/gcompose/src/PropertyWidgets.h
+++ b/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>
@@ -143,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:
@@ -167,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:
--- a/docs/algorithms/algoritm.md
+++ b/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
+```
+
+
--- a/docs/transformation_system.md
+++ b/docs/transformation_system.md
@@ -1,73 +0,0 @@
-# Transformation Flow and Synchronization System
-
-This document describes how transformations are applied and synchronized between the interactive 3D viewport, the visualization puppets, and the underlying mathematical models within the `uLib` framework.
-
-## Architecture Overview
-
-The system follows a Model-View-Controller (MVC) like pattern where:
- **Model**: `uLib::AffineTransform` (or derived classes like `ContainerBox`).
- **View/Puppet**: `uLib::Vtk::Puppet` (and specialized derivations like `Vtk::Assembly`).
- **Controller/Interaction**: `vtkHandlerWidget` (the transformation gizmo).
-
---
-
-## 1. Interaction Flow (Gizmo -> Model)
-
-When a user interacts with the `vtkHandlerWidget` (dragging arrows, rings, or cubes), the following chain of events occurs:
-
-```mermaid
-sequenceDiagram
-    participant User
-    participant HW as vtkHandlerWidget
-    participant VP as vtkViewport
-    participant P as vtkPuppet
-    participant M as uLib Model
-
-    User->>HW: Drag handle (MouseMove)
-    HW->>HW: Calculate Delta Matrix (op)
-    HW->>HW: Total = StartState * op
-    HW->>HW: Decompose Total into P, O, S
-    HW->>P: SetPosition, SetOrientation, SetScale
-    HW-->>VP: Invoke InteractionEvent
-    VP->>P: SyncFromVtk()
-    P->>P: Get local matrix from VTK Prop
-    P->>M: SetMatrix(matrix)
-    M-->>M: Update local properties (P, O, S)
-    M-->>P: Emit Updated signal
-    P->>P: Puppet::Update()
-    P->>P: (Redundant sanity write to Prop)
-```
-
-### Key Principles:
- **Single Source of Truth**: The `uLib::AffineTransform` is the owner of the transformation state.
- **Internal TRS vs UserMatrix**: We apply transformations directly to VTK's internal `Position`, `Orientation`, and `Scale` properties. This ensures the data is "visible" to VTK actors and simplifies decomposition.
- **Cumulative Bias Avoidance**: The `HandlerWidget` calculates transformations relative to the state at the start of the click, preventing numerical drift during a single drag operation.
-
---
-
-## 2. Synchronization Loop Resolution
-
-To prevent infinite loops and "double-transformation" artifacts (especially in assemblies), the following protections are in place:
-
-1. **Hierarchy Isolation**: The `Puppet` base class distinguishes between the **Root Property** (which receives the puppet's master transformation) and **Sub-Parts** (which only receive appearance updates like color/visibility). This prevents parts from inheriting the same displacement twice.
-2. **Re-entrancy Guards**: Puppets use an `m_InUpdate` flag to prevent a feedback loop where `SyncFromVtk` triggers a Model Update, which then re-triggers the Puppet Update.
-3. **Signal Blocking**: In specialized cases (like `vtkAssembly`), `m_BlockUpdate` is used to prevent the model-to-puppet push during a puppet-to-model sync.
-
---
-
-## 3. Undo System (Ctrl-Z)
-
-### Current Implementation (Delta Chain)
-Currently, the system maintains a `m_TransformChain` of delta matrices.
- **Record**: After every drag, a delta matrix ($M_{delta} = M_{end} \cdot M_{start}^{-1}$) is appended to the chain.
- **Undo**: The last delta is removed, and the prop is reconstructed by reapplying the remaining chain from a `BaseMatrix`.
-
-### Planned Improvement (TRS Snapshots)
-We are migrating to a `uLib::TRS` snapshot system for Undo.
- **Record**: At the start of a drag, the current `TRS` state of the object is pushed to the `m_UndoStack`.
- **Undo**: The top `TRS` is popped and applied directly to the model.
-
-This approach is more robust because:
- It eliminates matrix multiplication error accumulation.
- It bypasses rotation convention/order issues (Gimbal lock in deltas).
- It returns the object to exactly its previous property values.
--- a/src/Core/Algorithm.h
+++ b/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
--- a/src/Core/CMakeLists.txt
+++ b/src/Core/CMakeLists.txt
@@ -1,5 +1,6 @@

 set(HEADERS
+    Algorithm.h
    Archives.h
    Array.h
    Collection.h 
--- a/src/Core/Object.h
+++ b/src/Core/Object.h
@@ -52,7 +52,6 @@ class polymorphic_oarchive;
 namespace uLib {

 class PropertyBase;
-class ObjectsContext;

 class Version {
 public:
@@ -102,9 +101,6 @@ public:
  // FIXX !!!
  virtual void DeepCopy(const Object &copy);

-  /** @brief Returns a nested context for children objects, if any. */
-  virtual ObjectsContext* GetChildren() { return nullptr; }
-
  ////////////////////////////////////////////////////////////////////////////
  // SERIALIZATION //

--- a/src/Core/ObjectsContext.h
+++ b/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();

    virtual const char * GetClassName() const { return "ObjectsContext"; }
-    virtual ObjectsContext* GetChildren() override { return this; }

    /**
     * @brief Adds an object to the context.
--- a/src/Core/Property.h
+++ b/src/Core/Property.h
@@ -36,13 +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 ""; }
-
  std::string GetQualifiedName() const {
      if (GetGroup().empty()) return GetName();
      return GetGroup() + "." + GetName();
@@ -70,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_HasRange(false), m_HasDefault(false) {
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(valuePtr), m_own(false) {
      if (m_owner) {
          m_owner->RegisterProperty(this);
      }
@@ -79,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_HasRange(false), m_HasDefault(true), m_Default(defaultValue) {
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(new T(defaultValue)), m_own(true) {
      if (m_owner) {
          m_owner->RegisterProperty(this);
      }
@@ -112,61 +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;
-    ValidateT<T>(val);
-    if (*m_value != val) {
-      *m_value = val;
+    if (*m_value != value) {
+      *m_value = value;
      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; }
-
-  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) {
@@ -192,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;
@@ -204,11 +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;
 };

 /**
@@ -302,8 +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());
            m_Object->RegisterDynamicProperty(p);
        }
    }
--- a/src/Core/Serializable.h
+++ b/src/Core/Serializable.h
@@ -77,30 +77,15 @@ 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;
-  T m_max;
-  bool m_has_default;
-  T m_default;

 public:
-  explicit hrp(const char *name_, T &t, const char* units_ = nullptr) 
-    : m_name(name_), m_units(units_), m_value(t), m_has_range(false), m_has_default(false) {}
-
-  hrp& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
-  hrp& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+  explicit hrp(const char *name_, T &t, const char* units_ = nullptr) : m_name(name_), m_units(units_), m_value(t) {}

  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; }
-
  BOOST_SERIALIZATION_SPLIT_MEMBER()

  template <class Archivex>
@@ -125,23 +110,16 @@ class hrp_enum : public boost::serialization::wrapper_traits<hrp_enum<T>> {
  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; }
+    : 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; }

-  bool has_default() const { return m_has_default; }
-  const T& default_val() const { return m_default; }
-
  BOOST_SERIALIZATION_SPLIT_MEMBER()

  template <class Archivex>
--- a/src/Core/testing/AlgorithmTest.cpp
+++ b/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;
+}
--- a/src/Core/testing/CMakeLists.txt
+++ b/src/Core/testing/CMakeLists.txt
@@ -29,6 +29,7 @@ set( TESTS
        OpenMPTest
        TeamTest
        AffinityTest
+        AlgorithmTest
 )

 set(LIBRARIES
--- a/src/HEP/Geant/EmitterPrimary.hh
+++ b/src/HEP/Geant/EmitterPrimary.hh
@@ -23,7 +23,7 @@ class G4Event;
 namespace uLib {
 namespace Geant {

-class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransform
+class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public Object, public AffineTransform
 {
  public:

--- a/src/Math/Assembly.cpp
+++ b/src/Math/Assembly.cpp
@@ -25,9 +25,7 @@ Assembly::Assembly()
      m_BBoxMin(Vector3f::Zero()),
      m_BBoxMax(Vector3f::Zero()),
      m_ShowBoundingBox(false),
-      m_GroupSelection(true) {
-    ULIB_ACTIVATE_PROPERTIES(*this);
-}
+      m_GroupSelection(true) {}

 Assembly::Assembly(const Assembly &copy)
    : ObjectsContext(copy),
@@ -37,25 +35,13 @@ Assembly::Assembly(const Assembly &copy)
      m_ShowBoundingBox(copy.m_ShowBoundingBox),
      m_GroupSelection(copy.m_GroupSelection) {}

-Assembly::~Assembly() {
-    for (auto const& [obj, conn] : m_ChildConnections) {
-        conn.disconnect();
-    }
-    m_ChildConnections.clear();
-}
+Assembly::~Assembly() {}

 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)
-    });
-    this->ComputeBoundingBox();
 }

 void Assembly::RemoveObject(Object *obj) {
@@ -63,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() {
@@ -86,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
-            // Since it is parented to 'this', GetMatrix() is sufficient.
-            Matrix4f m = box->GetMatrix();
+            // ContainerBox: wm is matrix from unit cube [0,1] to assembly base
+            Matrix4f m = invAsm * box->GetWorldMatrix();
            for (int i = 0; i < 8; ++i) {
                float x = (i & 1) ? 1.0f : 0.0f;
                float y = (i & 2) ? 1.0f : 0.0f;
@@ -103,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;
@@ -119,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);
--- a/src/Math/Assembly.h
+++ b/src/Math/Assembly.h
@@ -45,19 +45,12 @@ namespace uLib {
 */
 class Assembly : public ObjectsContext, public AffineTransform {
 public:
-    uLibTypeMacro(Assembly, ObjectsContext, AffineTransform)
    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("AffineTransform", boost::serialization::base_object<AffineTransform>(*this));
-        ar & boost::serialization::make_hrp("GroupSelection", m_GroupSelection);
-    }
-
    virtual void AddObject(Object* obj) override;
    virtual void RemoveObject(Object* obj) override;

@@ -99,7 +92,7 @@ signals:
        if (m_InUpdated) return;  // break signal recursion
        m_InUpdated = true;
        this->ComputeBoundingBox();
-        ULIB_SIGNAL_EMIT(Object::Updated);
+        ULIB_SIGNAL_EMIT(Assembly::Updated);
        m_InUpdated = false;
    }

@@ -109,7 +102,6 @@ private:
    bool     m_ShowBoundingBox;
    bool     m_GroupSelection;
    bool     m_InUpdated = false;
-    std::map<Object*, Connection> m_ChildConnections;
 };

 } // namespace uLib
--- a/src/Math/ContainerBox.h
+++ b/src/Math/ContainerBox.h
@@ -44,17 +44,16 @@ namespace uLib {
 * that defines the box's specific origin and size relative to its own
 * coordinate system.
 */
-class ContainerBox : public AffineTransform {
+class ContainerBox : public AffineTransform, public Object {
+
+  typedef AffineTransform BaseClass;

 public:
-  uLibTypeMacro(ContainerBox, AffineTransform)
-
-  virtual const char * GetClassName() const override { return "ContainerBox"; }
-
  ////////////////////////////////////////////////////////////////////////////
  // PROPERTIES //
-  Vector3f Size;
-  Vector3f Origin;
+  Property<Vector3f> p_Size;
+  Property<Vector3f> p_Origin;
+  virtual const char * GetClassName() const { return "ContainerBox"; }

  /**
   * @brief Default constructor.
@@ -62,10 +61,10 @@ public:
   */
  ContainerBox()
      : m_LocalT(this), // BaseClass is Parent of m_LocalTransform
-        Size(1.0f, 1.0f, 1.0f),
-        Origin(0.0f, 0.0f, 0.0f) {
-    ULIB_ACTIVATE_PROPERTIES(*this);
-    this->Sync();
+        p_Size(this, "Size", Vector3f(1.0f, 1.0f, 1.0f)),
+        p_Origin(this, "Origin", Vector3f(0.0f, 0.0f, 0.0f)) {
+    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
+    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
  }

  /**
@@ -74,10 +73,11 @@ public:
   */
  ContainerBox(const Vector3f &size)
      : m_LocalT(this),
-        Size(size),
-        Origin(0.0f, 0.0f, 0.0f) {
-    ULIB_ACTIVATE_PROPERTIES(*this);
-    this->Sync();
+        p_Size(this, "Size", size),
+        p_Origin(this, "Origin", Vector3f(0.0f, 0.0f, 0.0f)) {
+    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
+    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
+    this->SetSize(size);
  }

  /**
@@ -85,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
        AffineTransform(copy),
-        Size(copy.Size),
-        Origin(copy.Origin) {
-    ULIB_ACTIVATE_PROPERTIES(*this);
-    this->Sync();
-  }
-
-  /**
-   * @brief Serialization template for property registration and persistence.
-   */
-  template <class ArchiveT>
-  void serialize(ArchiveT & ar, const unsigned int version) {
-    ar & HRP(Size);
-    ar & HRP(Origin);
+        p_Size(this, "Size", copy.p_Size),
+        p_Origin(this, "Origin", copy.p_Origin) {
+    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);
  }

  /**
@@ -107,7 +99,7 @@ public:
   * @param v The origin position vector.
   */
  void SetOrigin(const Vector3f &v) { 
-    Origin = v;
+    p_Origin = v;
    m_LocalT.SetPosition(v); 
  }

@@ -123,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);
@@ -202,27 +194,26 @@ 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 */
-  virtual void Updated() override { 
-      this->Sync();
-      ULIB_SIGNAL_EMIT(Object::Updated); 
+  // signal to emit when the box is updated //
+  virtual void Updated() override { ULIB_SIGNAL_EMIT(ContainerBox::Updated); }
+
+private slots:
+  void SyncSize() {
+      this->SetSize(p_Size);
  }

-private:
-  /** Synchronizes internal transformation with properties */
-  void Sync() {
-      this->SetOrigin(Origin);
-      this->SetSize(Size);
+  void SyncOrigin() {
+      this->SetOrigin(p_Origin);
  }


--- a/src/Math/Cylinder.h
+++ b/src/Math/Cylinder.h
@@ -39,17 +39,10 @@ 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 AffineTransform {
+class Cylinder : public AffineTransform, public Object {

 public:
-    uLibTypeMacro(Cylinder, AffineTransform)
-
-    /**
-     * @brief PROPERTIES
-     */
-    float Radius;
-    float Height;
-    int Axis;
+    uLibTypeMacro(Cylinder, Object)

    virtual const char * GetClassName() const override { return "Cylinder"; }

@@ -58,7 +51,7 @@ public:
     */
    Cylinder() : m_LocalT(this), Radius(1.0), Height(1.0), Axis(1) {
        ULIB_ACTIVATE_PROPERTIES(*this);
-        this->Sync();
+        UpdateLocalMatrix();
    }

    /**
@@ -67,7 +60,7 @@ public:
    Cylinder(float radius, float height, int axis = 1) 
        : m_LocalT(this), Radius(radius), Height(height), Axis(axis) {
        ULIB_ACTIVATE_PROPERTIES(*this);
-        this->Sync();
+        UpdateLocalMatrix();
    }

    /**
@@ -76,7 +69,7 @@ public:
    Cylinder(const Cylinder &copy)
        : m_LocalT(this), AffineTransform(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
        ULIB_ACTIVATE_PROPERTIES(*this);
-        this->Sync();
+        this->UpdateLocalMatrix();
    }

    /**
@@ -92,7 +85,7 @@ public:
    /** 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,33 +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 { 
-        this->Sync();
-        ULIB_SIGNAL_EMIT(Object::Updated); 
+        this->UpdateLocalMatrix();
+        ULIB_SIGNAL_EMIT(Cylinder::Updated); 
    }

 private:
-  /** Synchronizes internal transformation with properties */
-  void Sync() {
-      m_LocalT = AffineTransform(this);
-      if (Axis == 0) m_LocalT.Scale(Vector3f(Height, Radius, Radius));
-      else if (Axis == 1) m_LocalT.Scale(Vector3f(Radius, Height, Radius));
-      else m_LocalT.Scale(Vector3f(Radius, Radius, Height));
-  }
+    /** Recalculates the internal local matrix based on dimensions and axis */
+    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));
+    }

-
-private:
+    float Radius;
+    float Height;
+    int Axis;
    AffineTransform m_LocalT;
 };

--- a/src/Math/Geometry.h
+++ b/src/Math/Geometry.h
@@ -35,11 +35,10 @@

 namespace uLib {

-class Geometry : public AffineTransform {
+class Geometry : public AffineTransform, public Object {
 public:
-    uLibTypeMacro(Geometry, AffineTransform)

-    virtual const char * GetClassName() const override { return "Geometry"; }
+    virtual const char * GetClassName() const { return "Geometry"; }

    virtual Vector3f ToLinear(const Vector3f& curved_space) const {
        return curved_space;
@@ -71,7 +70,6 @@ public:

 class CylindricalGeometry : public Geometry {
 public:
-    uLibTypeMacro(CylindricalGeometry, Geometry)
    CylindricalGeometry() {}

    Vector3f ToLinear(const Vector3f& cylindrical) const {
@@ -90,10 +88,9 @@ public:

 class SphericalGeometry : public Geometry {
 public:
-    uLibTypeMacro(SphericalGeometry, Geometry)
    SphericalGeometry() {}

-    virtual const char * GetClassName() const override { return "SphericalGeometry"; }
+    virtual const char * GetClassName() const { return "SphericalGeometry"; }

    Vector3f ToLinear(const Vector3f& spherical) const {
        float r = spherical.x();
@@ -115,10 +112,9 @@ public:

 class ToroidalGeometry : public Geometry {
 public:
-    uLibTypeMacro(ToroidalGeometry, Geometry)
    ToroidalGeometry(float Rtor) : m_Rtor(Rtor) {}

-    virtual const char * GetClassName() const override { return "ToroidalGeometry"; }
+    virtual const char * GetClassName() const { return "ToroidalGeometry"; }

    Vector3f ToLinear(const Vector3f& toroidal) const {
        float r = toroidal.x();
--- a/src/Math/MathRegistrations.cpp
+++ b/src/Math/MathRegistrations.cpp
@@ -5,14 +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(ContainerBox)
 ULIB_REGISTER_OBJECT(Cylinder)
-ULIB_REGISTER_OBJECT(Assembly)
 ULIB_REGISTER_OBJECT(CylindricalGeometry)
 ULIB_REGISTER_OBJECT(SphericalGeometry)
 ULIB_REGISTER_OBJECT(TriangleMesh)
--- a/src/Math/QuadMesh.h
+++ b/src/Math/QuadMesh.h
@@ -34,12 +34,11 @@

 namespace uLib {

-class QuadMesh : public AffineTransform
+class QuadMesh : public AffineTransform, public Object
 {
 public:
-    uLibTypeMacro(QuadMesh, AffineTransform)

-    virtual const char * GetClassName() const override { return "QuadMesh"; }
+    virtual const char * GetClassName() const { return "QuadMesh"; }

    void PrintSelf(std::ostream &o);

--- a/src/Math/Transform.h
+++ b/src/Math/Transform.h
@@ -50,130 +50,36 @@
 #define U_TRANSFORM_H

 #include <Eigen/Geometry>
-#include "Math/Units.h"
 #include "Math/Dense.h"


 namespace uLib {

-
-////////////////////////////////////////////////////////////////////////////////
-/////////  TRS PARAMETERS  /////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-typedef Eigen::Affine3f AffineMatrix;
-
-class TRS {
-public:
-    Vector3f position = Vector3f::Zero();
-    Vector3f rotation = Vector3f::Zero();
-    Vector3f scaling  = Vector3f::Ones();
-
-    TRS() = default;
-
-    TRS(const class AffineTransform& at);
-
-    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);
-        
-        // Decompose to Euler angles matching VTK (M = Rz * Ry * Rx)
-        // Store internally as RADIANS (standard for uLib properties)
-        Vector3f euler = rot.eulerAngles(2, 1, 0); 
-        this->rotation = Vector3f(euler(2), euler(1), euler(0));
-    }
-
-    template <class ArchiveT>
-    void serialize(ArchiveT & ar, const unsigned int version) {
-        ar & HRPU(position, "mm");
-        ar & HRPU(rotation, "deg"); // Metadata informs UI to convert to/from degrees
-        ar & HRP(scaling);
-    }
-
-    AffineMatrix GetAffineMatrix() const {
-        AffineMatrix t = AffineMatrix::Identity();
-        t.translate(position);
-        
-        // rotation is in Radians here
-        t.rotate(Eigen::AngleAxisf(rotation.z(), Vector3f::UnitZ()));
-        t.rotate(Eigen::AngleAxisf(rotation.y(), Vector3f::UnitY()));
-        t.rotate(Eigen::AngleAxisf(rotation.x(), Vector3f::UnitX()));
-        
-        t.scale(scaling);
-        return t;
-    }
-};
-
 ////////////////////////////////////////////////////////////////////////////////
 /////////  AFFINE TRANSFORM  WRAPPER  //////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-class AffineTransform : virtual public Object {
-public:
-    uLibTypeMacro(AffineTransform, Object)
-
-    TRS Transform;
-
-private:
-    void NotifyProperties() {
-        PropertyBase *p;
-        if ((p = this->GetProperty("Transform.position"))) p->Updated();
-        if ((p = this->GetProperty("Transform.rotation"))) p->Updated();
-        if ((p = this->GetProperty("Transform.scaling"))) p->Updated();
-    }
-
+class AffineTransform {
 protected:
    Eigen::Affine3f  m_T;
    AffineTransform *m_Parent;
-
 public:
    AffineTransform() :
        m_T(Matrix4f::Identity()),
        m_Parent(NULL)
-    {
-        ULIB_ACTIVATE_PROPERTIES(*this);
-        this->Sync();
-    }
+    {}

    virtual ~AffineTransform() {}

    AffineTransform(AffineTransform *parent) :
        m_T(Matrix4f::Identity()),
        m_Parent(parent)
-    {
-        ULIB_ACTIVATE_PROPERTIES(*this);
-        this->Sync();
-    }
+    {}

    AffineTransform(const AffineTransform &copy) :
        m_T(copy.m_T),
-        m_Parent(copy.m_Parent),
-        Transform(copy.Transform)
-    {
-        ULIB_ACTIVATE_PROPERTIES(*this);
-        this->Sync();
-    }
-
-    /**
-     * @brief Registration of properties in groups.
-     */
-    template <class ArchiveT>
-    void serialize(ArchiveT & ar, const unsigned int version) {
-        ar & boost::serialization::make_nvp("Transform", Transform);
-    }
+        m_Parent(copy.m_Parent)
+    {}

    Eigen::Affine3f& GetTransform() { return m_T; }

@@ -181,11 +87,7 @@ public:

    void SetParent(AffineTransform *name) { this->m_Parent = name; }

-    void SetMatrix (Matrix4f mat) { 
-        m_T.matrix() = mat; 
-        this->UpdatePropertiesFromMatrix();
-    }
-    
+    void SetMatrix (Matrix4f mat) { m_T.matrix() = mat; }
    Matrix4f GetMatrix() const { return m_T.matrix(); }

    Matrix4f GetWorldMatrix() const
@@ -194,56 +96,32 @@ public:
        else return  m_Parent->GetWorldMatrix() * m_T.matrix(); // T = B * A //
    }

-    void SetPosition(const Vector3f v) { 
-        this->Transform.position = v; 
-        this->Updated();
-        this->NotifyProperties();
-    }
-    Vector3f GetPosition() const { return this->Transform.position; }
+    void SetPosition(const Vector3f v) { this->m_T.translation() = v; }

-    void SetOrientation(const Vector3f v) { 
-        this->Transform.rotation = v; 
-        this->Updated();
-        this->NotifyProperties();
-    }
-    Vector3f GetOrientation() const { return this->Transform.rotation; }
+    Vector3f GetPosition() const { return this->m_T.translation(); }

-    void SetScale(const Vector3f v) { 
-        this->Transform.scaling = v; 
-        this->Updated();
-        this->NotifyProperties();
-    }
-    Vector3f GetScale() const { return this->Transform.scaling; }
-
-    void SetRotation(const Matrix3f m) { 
-        this->m_T.linear() = m; 
-        this->UpdatePropertiesFromMatrix();
-    }
+    void SetRotation(const Matrix3f m) { this->m_T.linear() = m; }

    Matrix3f GetRotation() const { return this->m_T.rotation(); }

-    void Translate(const Vector3f v) { 
-        this->Transform.position += v; 
-        this->Sync();
-    }
+    void Translate(const Vector3f v) { this->m_T.translate(v); }

-    void Scale(const Vector3f v) { 
-        this->Transform.scaling = this->Transform.scaling.cwiseProduct(v);
-        this->Sync();
+    void Scale(const Vector3f v) { this->m_T.scale(v); }
+
+    Vector3f GetScale() const { 
+        return Vector3f(m_T.linear().col(0).norm(), 
+                        m_T.linear().col(1).norm(), 
+                        m_T.linear().col(2).norm()); 
    }


-    void Rotate(const Matrix3f m) { 
-        this->m_T.rotate(m); 
-        this->UpdatePropertiesFromMatrix();
-    }
+    void Rotate(const Matrix3f m) { this->m_T.rotate(m); }

    void Rotate(const float angle, Vector3f axis)
    {
-        axis.normalize(); 
+        axis.normalize(); // prehaps not necessary ( see eigens )
        Eigen::AngleAxisf ax(angle,axis);
        this->m_T.rotate(Eigen::Quaternion<float>(ax));
-        this->UpdatePropertiesFromMatrix();
    }

    void Rotate(const Vector3f euler_axis) {
@@ -251,14 +129,17 @@ public:
        Rotate(angle,euler_axis);
    }

-    void PreRotate(const Matrix3f m) { this->m_T.prerotate(m); this->UpdatePropertiesFromMatrix(); }
+    void PreRotate(const Matrix3f m) { this->m_T.prerotate(m); }

    void QuaternionRotate(const Vector4f q)
-    { this->m_T.rotate(Eigen::Quaternion<float>(q)); this->UpdatePropertiesFromMatrix(); }
+    { this->m_T.rotate(Eigen::Quaternion<float>(q)); }

    void EulerYZYRotate(const Vector3f e) {
-        this->Transform.rotation = e;
-        this->Sync();
+        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)
@@ -266,42 +147,9 @@ public:
        Matrix3f mat = Matrix3f::Identity();
        mat.col(first).swap(mat.col(second));
        m_T.rotate(mat);
-        this->UpdatePropertiesFromMatrix();
-    }
-
-    /**
-     * @brief Decomposes the internal matrix m_T back into Position, Orientation, and Scale properties.
-     */
-    void UpdatePropertiesFromMatrix() {
-        this->Transform.FromMatrix(this->GetMatrix());
-        
-        PropertyBase *p;
-        if ((p = this->GetProperty("Transform.position"))) p->Updated();
-        if ((p = this->GetProperty("Transform.rotation"))) p->Updated();
-        if ((p = this->GetProperty("Transform.scaling"))) p->Updated();
-    }
-
-signals:
-    /** Signal emitted when properties change */
-    virtual void Updated() override { 
-        this->Sync();
-        ULIB_SIGNAL_EMIT(Object::Updated); 
-    }
-
-private:
-    void Sync() {
-        m_T.matrix() = this->Transform.GetAffineMatrix().matrix();
    }
 };

-inline TRS::TRS(const AffineTransform& at) {
-    this->position = at.GetPosition();
-    this->rotation = at.GetOrientation();
-    this->scaling  = at.GetScale();
-}
-
-
-


 }
--- a/src/Math/TriangleMesh.h
+++ b/src/Math/TriangleMesh.h
@@ -37,12 +37,11 @@

 namespace uLib {

-class TriangleMesh : public AffineTransform
+class TriangleMesh : public AffineTransform, public Object
 {
 public:
-    uLibTypeMacro(TriangleMesh, AffineTransform)

-    virtual const char * GetClassName() const override { return "TriangleMesh"; }
+    virtual const char * GetClassName() const { return "TriangleMesh"; }

    void PrintSelf(std::ostream &o);

--- a/src/Math/VoxImageFilter.h
+++ b/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"; }
+  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 {
-    return this->m_KernelData;
-  }
-  inline Kernel<VoxelT> &GetKernelData() { return this->m_KernelData; }
+  // Accessors //////////////////////////////////////////////////////////////////

-  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
--- a/src/Math/VoxImageFilter.hpp
+++ b/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)]; }
-  inline T &operator[](const int &id) { return m_Data[id]; }
-  inline int GetCenterData() const;
+  T &operator[](const Vector3i &id) { return m_Data[Map(id)]; }
+  T &operator[](const int &id) { return m_Data[id]; }
+  int GetCenterData() const;

-  inline DataAllocator<T> &Data() { return this->m_Data; }
-
-  inline const DataAllocator<T> &ConstData() const { return this->m_Data; }
+  DataAllocator<T> &Data() { return m_Data; }
+  const DataAllocator<T> &ConstData() const { return 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,26 +99,42 @@ template <typename T> void Kernel<T>::PrintSelf(std::ostream &o) const {
  }
 }

+////////////////////////////////////////////////////////////////////////////////
+//// VOXIMAGEFILTER IMPLEMENTATION /////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-#define _TPL_ template <typename VoxelT, typename AlgorithmT>
-#define _TPLT_ VoxelT, AlgorithmT
+template <typename VoxelT, typename CrtpImplT>
+VoxImageFilter<VoxelT, CrtpImplT>::VoxImageFilter(const Vector3i &size)
+    : m_KernelData(size)
+    , m_Image(nullptr)
+    , m_CrtpImpl(static_cast<CrtpImplT *>(this))
+{}

-_TPL_
-VoxImageFilter<_TPLT_>::VoxImageFilter(const Vector3i &size)
-    : m_KernelData(size), t_Algoritm(static_cast<AlgorithmT *>(this)) {}
-
-_TPL_
-void VoxImageFilter<_TPLT_>::Run() {
+template <typename VoxelT, typename CrtpImplT>
+VoxImage<VoxelT>* VoxImageFilter<VoxelT, CrtpImplT>::Process(
+    VoxImage<VoxelT>* const& image) {
+  if (m_Image != image) SetImage(image);
  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;
 }

-_TPL_
-void VoxImageFilter<_TPLT_>::SetKernelOffset() {
+template <typename VoxelT, typename CrtpImplT>
+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) {
@@ -127,10 +146,10 @@ void VoxImageFilter<_TPLT_>::SetKernelOffset() {
  }
 }

-_TPL_
-float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v) {
+template <typename VoxelT, typename CrtpImplT>
+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);
@@ -140,12 +159,9 @@ float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v) {
                 0.25 * (3 - (dim(0) % 2) - (dim(1) % 2) - (dim(2) % 2)));
 }

-_TPL_
-void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(
+template <typename VoxelT, typename CrtpImplT>
+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) {
@@ -156,38 +172,39 @@ void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(
      }
    }
  }
-  // m_KernelData.SetDataOrder(order);
 }

-_TPL_
-void VoxImageFilter<_TPLT_>::SetKernelSpherical(float (*shape)(float)) {
+template <typename VoxelT, typename CrtpImplT>
+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));
      }
    }
  }
 }

-_TPL_ template <class ShapeT>
-void VoxImageFilter<_TPLT_>::SetKernelSpherical(ShapeT shape) {
+template <typename VoxelT, typename CrtpImplT>
+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));
      }
    }
  }
 }

-_TPL_
-void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(
+template <typename VoxelT, typename CrtpImplT>
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelWeightFunction(
    float (*shape)(const Vector3f &)) {
  const Vector3i &dim = m_KernelData.GetDims();
  Vector3i id;
@@ -195,20 +212,19 @@ void VoxImageFilter<_TPLT_>::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);
      }
    }
  }
 }

-_TPL_ template <class ShapeT>
-void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(ShapeT shape) {
+template <typename VoxelT, typename CrtpImplT>
+template <class ShapeT>
+void VoxImageFilter<VoxelT, CrtpImplT>::SetKernelWeightFunction(ShapeT shape) {
  Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
  const Vector3i &dim = m_KernelData.GetDims();
  Vector3i id;
@@ -216,45 +232,16 @@ void VoxImageFilter<_TPLT_>::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);
      }
    }
  }
 }

-_TPL_
-void VoxImageFilter<_TPLT_>::SetImage(Abstract::VoxImage *image) {
-  this->m_Image = reinterpret_cast<VoxImage<VoxelT> *>(image);
-  this->SetKernelOffset();
-}
-
-_TPL_
-float VoxImageFilter<_TPLT_>::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;
-}
-
-#undef _TPLT_
-#undef _TPL_
-
 } // namespace uLib

 #endif // VOXIMAGEFILTER_HPP
--- a/src/Math/VoxImageFilterABTrim.hpp
+++ b/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
--- a/src/Math/VoxImageFilterCustom.hpp
+++ b/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();
--- a/src/Math/VoxImageFilterLinear.hpp
+++ b/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
--- a/src/Math/VoxImageFilterThreshold.hpp
+++ b/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 :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT> > {
+class VoxFilterAlgorithmThreshold
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT>> {

-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT> > BaseClass;
-    //    ULIB_OBJECT_PARAMETERS(BaseClass) {
-    //        float threshold;
-    //    };
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmThreshold<VoxelT>> BaseClass;

-    float m_threshold;
+  float m_threshold;

 public:
-    VoxFilterAlgorithmThreshold(const Vector3i &size) : BaseClass(size)
-    {
-        //        init_parameters();
-        m_threshold = 0;
-    }
+  VoxFilterAlgorithmThreshold(const Vector3i &size)
+      : BaseClass(size), m_threshold(0) {}

-    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 );
-    }
+  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);
+  }
 };

-//template <typename VoxelT>
-//inline void VoxFilterAlgorithmThreshold<VoxelT>::init_parameters()
-//{
-//    parameters().threshold = 0;
-//}
-
-}
+} // namespace uLib

 #endif // VOXIMAGEFILTERTHRESHOLD_HPP
--- a/src/Math/testing/AlgorithmCudaChainTest.cpp
+++ b/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;
+}
--- a/src/Math/testing/CMakeLists.txt
+++ b/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()
--- a/src/Vtk/CMakeLists.txt
+++ b/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
            )

--- a/src/Vtk/HEP/Detectors/vtkMuonEvent.h
+++ b/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 {
--- a/src/Vtk/HEP/Detectors/vtkMuonScatter.h
+++ b/src/Vtk/HEP/Detectors/vtkMuonScatter.h
@@ -46,7 +46,7 @@

 #include "HEP/Detectors/MuonScatter.h"
 #include "Vtk/uLibVtkInterface.h"
-#include "Vtk/Math/vtkPolydata.h"
+#include "Vtk/vtkPolydata.h"

 class vtkRenderWindowInteractor;

--- a/src/Vtk/HEP/Geant/vtkGeantEvent.h
+++ b/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 {
--- a/src/Vtk/HEP/Geant/vtkGeantSolid.h
+++ b/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;

--- a/src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.h
+++ b/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
--- a/src/Vtk/Math/CMakeLists.txt
+++ b/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)
--- a/src/Vtk/Math/vtkAssembly.cpp
+++ b/src/Vtk/Math/vtkAssembly.cpp
@@ -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);
@@ -93,42 +92,39 @@ void Assembly::InstallPipe() {
 void Assembly::contentUpdate() {
    if (m_InUpdate) return;
    m_InUpdate = true;
-    m_BlockUpdate = false;
+
    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;
-    this->contentUpdate();
-    m_InUpdate = false;
-}
-
-void Assembly::SyncFromVtk() {
    if (m_InUpdate) return;
    if (!m_Content || !m_VtkAsm) return;

+    if (m_BlockUpdate) {
+        m_BlockUpdate = false;
+        return;
+    }
+
    m_InUpdate = true;

-    double pos[3], ori[3], scale[3];
-    m_VtkAsm->GetPosition(pos);
-    m_VtkAsm->GetOrientation(ori);
-    m_VtkAsm->GetScale(scale);
-    
-    m_Content->SetPosition(Vector3f(pos[0], pos[1], pos[2]));
-    m_Content->SetOrientation(Vector3f(ori[0], ori[1], ori[2]) * CLHEP::degree);
-    m_Content->SetScale(Vector3f(scale[0], scale[1], scale[2]));
+    // Pull VTK transform back into the uLib model
+    vtkMatrix4x4* vmat = m_VtkAsm->GetUserMatrix();
+    if (vmat) {
+        Matrix4f transform = VtkToMatrix4f(vmat);
+        m_Content->SetMatrix(transform);
+    }

    this->UpdateBoundingBox();
    if (m_ChildContext)
-        m_ChildContext->SyncFromVtk();
+        m_ChildContext->Update();

    m_Content->Updated(); // Notify change in model

@@ -139,7 +135,10 @@ void Assembly::SyncFromVtk() {
 void Assembly::UpdateTransform() {
    if (!m_Content || !m_VtkAsm) return;

-    this->ApplyTransform(m_VtkAsm);
+    Matrix4f mat = m_Content->GetMatrix();
+    vtkNew<vtkMatrix4x4> vmat;
+    Matrix4fToVtk(mat, vmat);
+    m_VtkAsm->SetUserMatrix(vmat);
    m_VtkAsm->Modified();
 }

--- a/src/Vtk/Math/vtkAssembly.h
+++ b/src/Vtk/Math/vtkAssembly.h
@@ -44,11 +44,7 @@ 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). */
    void contentUpdate();
--- a/src/Vtk/Math/vtkContainerBox.cpp
+++ b/src/Vtk/Math/vtkContainerBox.cpp
@@ -80,37 +80,53 @@ void vtkContainerBox::contentUpdate() {
  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);

-  TRS trs(*m_Content);
-  this->ApplyTransform(root);
+  Matrix4f transform = m_Content->GetMatrix();
+  Matrix4fToVtk(transform, vmat);

  root->Modified();
-  m_BlockUpdate = false;
+  m_BlockUpdate = true;
  Puppet::Update();
 }


 void vtkContainerBox::Update() {
-  this->contentUpdate();
-}
-
-void vtkContainerBox::SyncFromVtk() {
  RecursiveMutex::ScopedLock lock(this->m_UpdateMutex);
  if (!m_Content) return;
  
+  if (m_BlockUpdate) {
+    m_BlockUpdate = false;
+    return;
+  }
+
+  // Use Targeted Blocking: only block the feedback connection to this puppet
+  // boost::signals2::shared_connection_block block(m_Connection);
+
  vtkProp3D* assembly = vtkProp3D::SafeDownCast(this->GetProp());
  if (!assembly) return;

-  double pos[3], ori[3], scale[3];
-  assembly->GetPosition(pos);
-  assembly->GetOrientation(ori);
-  assembly->GetScale(scale);
+  vtkMatrix4x4* vmat = assembly->GetUserMatrix();
+  if (!vmat) return;
  
-  m_Content->SetPosition(Vector3f(pos[0], pos[1], pos[2]));
-  m_Content->SetOrientation(Vector3f(ori[0], ori[1], ori[2]) * CLHEP::degree);
-  m_Content->SetScale(Vector3f(scale[0], scale[1], scale[2]));
+  Matrix4f transform = VtkToMatrix4f(vmat);
+
+  // Update uLib model's affine transform
+  // if (m_Content->GetParent()) {
+  //   Matrix4f localT = m_Content->GetParent()->GetWorldMatrix().inverse() * transform;
+  //   m_Content->SetMatrix(localT);
+  // } else {
+  m_Content->SetMatrix(transform);
+  // }

  m_Content->Updated(); // Notify change
 }
@@ -159,11 +175,9 @@ void vtkContainerBox::InstallPipe() {
  
  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
  if (root) {
-      TRS trs(*c);
-      root->SetPosition(trs.position.x(), trs.position.y(), trs.position.z());
-      root->SetOrientation(trs.rotation.x(), trs.rotation.y(), trs.rotation.z());
-      root->SetScale(trs.scaling.x(), trs.scaling.y(), trs.scaling.z());
-      root->SetUserMatrix(nullptr);
+      vtkNew<vtkMatrix4x4> vmat;
+      Matrix4fToVtk(c->GetMatrix(), vmat);
+      root->SetUserMatrix(vmat);
  }
 }

--- a/src/Vtk/Math/vtkContainerBox.h
+++ b/src/Vtk/Math/vtkContainerBox.h
@@ -49,8 +49,7 @@ public:

  virtual void contentUpdate();

-  virtual void Update() override;
-  virtual void SyncFromVtk() override;
+  virtual void Update();

  virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }

--- a/src/Vtk/Math/vtkCylinder.cpp
+++ b/src/Vtk/Math/vtkCylinder.cpp
@@ -55,12 +55,17 @@ void vtkCylinder::contentUpdate() {
  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
  if (!root) return;

-  // 1. Placement handled by base Puppet class via Sync / Update logic
-  // Update internal pd->m_Transform from content
-  Puppet::Update();
+  // 1. Placement (Position/Rotation/Model-level Scale) goes to the root prop
+  vtkMatrix4x4* vmat = root->GetUserMatrix();
+  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,29 +83,23 @@ void vtkCylinder::contentUpdate() {
  }

  root->Modified();
+  Puppet::Update();
 }

 void vtkCylinder::Update() {
-  this->contentUpdate();
-}
-
-void vtkCylinder::SyncFromVtk() {
  if (!m_Content) return;

-  vtkProp3D* assembly = vtkProp3D::SafeDownCast(this->GetProp());
-  if (!assembly) return;
+  vtkProp3D* root = vtkProp3D::SafeDownCast(this->GetProp());
+  if (!root) return;

-  double pos[3], ori[3], scale[3];
-  assembly->GetPosition(pos);
-  assembly->GetOrientation(ori);
-  assembly->GetScale(scale);
+  vtkMatrix4x4* vmat = root->GetUserMatrix();
+  if (!vmat) return;
  
-  m_Content->SetPosition(Vector3f(pos[0], pos[1], pos[2]));
-  // Convert VTK degrees to model radians
-  m_Content->SetOrientation(Vector3f(ori[0], ori[1], ori[2]) * CLHEP::degree);
-  m_Content->SetScale(Vector3f(scale[0], scale[1], scale[2]));
+  // Pull the placement matrix directly from VTK
+  Matrix4f transform = VtkToMatrix4f(vmat);
+  m_Content->SetMatrix(transform);

-  m_Content->Updated(); // Notify change
+  m_Content->Updated();
 }

 void vtkCylinder::InstallPipe() {
--- a/src/Vtk/Math/vtkCylinder.h
+++ b/src/Vtk/Math/vtkCylinder.h
@@ -52,10 +52,7 @@ public:
  virtual void contentUpdate();

  /** Synchronizes the uLib model matrix with the VTK actor (e.g., after UI manipulation) */
-  virtual void Update() override;
-
-  /** Synchronizes the uLib model matrix with the VTK actor specifically for gizmo interactions */
-  virtual void SyncFromVtk() override;
+  virtual void Update();

  virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }

--- a/src/Vtk/Math/vtkQuadMesh.h
+++ b/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;
--- a/src/Vtk/Math/vtkTriangleMesh.h
+++ b/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;
--- a/src/Vtk/testing/CMakeLists.txt
+++ b/src/Vtk/testing/CMakeLists.txt
@@ -3,7 +3,6 @@ set(TESTS
        vtkViewerTest
        vtkHandlerWidget
        PuppetPropertyTest
-        PuppetParentingTest
        # vtkVoxImageTest
 #	vtkTriangleMeshTest
 )
--- a/src/Vtk/testing/PuppetParentingTest.cpp
+++ b/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->Update();
-    
-    // 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;
-}
--- a/src/Vtk/uLibVtkInterface.cxx
+++ b/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>
@@ -63,7 +62,6 @@
 #include "uLibVtkInterface.h"
 #include "vtkHandlerWidget.h"
 #include "Math/Dense.h"
-#include "Vtk/Math/vtkDense.h"
 #include "Core/Property.h"


@@ -76,6 +74,12 @@ namespace uLib {
 namespace Vtk {


+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// PUPPET //
+
 // PIMPL -------------------------------------------------------------------- //

 class PuppetData {
@@ -86,13 +90,16 @@ public:
        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() {
@@ -111,17 +118,18 @@ 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;
-    TRS m_Transform;
+    Vector3d m_Position;
+    Vector3d m_Orientation;
+    Vector3d m_Scale;

    void ApplyAppearance(vtkProp *p) {
-        if (!p) return;
        p->SetVisibility(m_Visibility);
        p->SetPickable(m_Selectable);
        p->SetDragable(m_Dragable);
@@ -137,35 +145,21 @@ public:
                    actor->GetProperty()->SetEdgeVisibility(0);
                }
            }
-            if (m_Color.x() != -1.0) {
-                double c[3] = {m_Color.x(), m_Color.y(), m_Color.z()};
-                actor->GetProperty()->SetColor(c);
+            if (m_Color[0] != -1.0) {
+                actor->GetProperty()->SetColor(m_Color);
            }

            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();
-            parts->InitTraversal();
-            for (int i = 0; i < parts->GetNumberOfItems(); ++i) {
-                this->ApplyAppearance(parts->GetNextProp3D());
-            }
        }
-    }

-    void ApplyTransform(vtkProp3D* p3d) {
-        if (p3d) {
-            p3d->SetPosition(m_Transform.position.x(), m_Transform.position.y(), m_Transform.position.z());
-            
-            // Convert Model Radians to VTK Degrees
-            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());
-            p3d->SetUserMatrix(nullptr);
+        // Handle transformation if it's a Prop3D
+        if (auto* p3d = vtkProp3D::SafeDownCast(p)) {
+            // NOTE: Usually managed by Puppet::Update from model, but here for direct prop manipulation
+            // p3d->SetPosition(m_Position.data());
+            // p3d->SetOrientation(m_Orientation.data());
+            // p3d->SetScale(m_Scale.data());
        }
    }

@@ -208,7 +202,6 @@ public:
            }

            if (root) {
-                // Now that we use internal TRS, the prop's total matrix is GetMatrix()
                m_HighlightActor->SetUserMatrix(root->GetMatrix());
            }

@@ -233,15 +226,6 @@ public:



-
-
-
-
-
-
-
-
-
 Puppet::Puppet() : Object(), pd(new PuppetData) { 
    ULIB_ACTIVATE_DISPLAY_PROPERTIES;
    for (auto* p : this->GetDisplayProperties()) {
@@ -281,11 +265,8 @@ void Puppet::SetProp(vtkProp *prop)
                    pd->m_Representation = vp->GetRepresentation();
                if (pd->m_Opacity < 0)
                    pd->m_Opacity = vp->GetOpacity();
-                if (pd->m_Color.x() < 0) {
-                    double c[3];
-                    vp->GetColor(c);
-                    pd->m_Color = Vector3d(c[0], c[1], c[2]);
-                }
+                if (pd->m_Color[0] < 0)
+                    vp->GetColor(pd->m_Color);
            }
        }
    }
@@ -296,16 +277,6 @@ 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()
 {
@@ -525,15 +496,14 @@ void Puppet::Update()
 {
    vtkProp* root = this->GetProp();
    if (root) {
-        // Handle transformation synchronization from content
-        if (auto* content = dynamic_cast<uLib::AffineTransform*>(GetContent())) {
-            pd->m_Transform = *content; // Uses TRS(const AffineTransform&)
-        }
-
-        if (auto* p3d = vtkProp3D::SafeDownCast(root)) {
-             pd->ApplyTransform(p3d);
-        }
        pd->ApplyAppearance(root);
+        
+        // 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();
@@ -569,39 +539,23 @@ void Puppet::Update()
    }
 }

-
 void Puppet::SyncFromVtk()
 {
    vtkProp* root = this->GetProp();
    if (auto* p3d = vtkProp3D::SafeDownCast(root)) {
-        // Handle content synchronization if it's an AffineTransform
-        if (auto* content = dynamic_cast<uLib::AffineTransform*>(GetContent())) {
-            double pos[3], ori[3], scale[3];
-            p3d->GetPosition(pos);
-            p3d->GetOrientation(ori);
-            p3d->GetScale(scale);
+        double pos[3], ori[3], scale[3];
+        p3d->GetPosition(pos);
+        p3d->GetOrientation(ori);
+        p3d->GetScale(scale);

-            // Convert VTK Degrees to Model Radians
-            content->SetPosition(Vector3f(pos[0], pos[1], pos[2]));
-            content->SetOrientation(Vector3f(ori[0], ori[1], ori[2]) * CLHEP::degree);
-            content->SetScale(Vector3f(scale[0], scale[1], scale[2]));
-            
-            // Re-sync internal puppet properties from the now-updated content
-            pd->m_Transform = *content;
-        }
-        else {
-            // Update internal puppet TRS directly from VTK components
-            double pos[3], ori[3], scale[3];
-            p3d->GetPosition(pos);
-            p3d->GetOrientation(ori);
-            p3d->GetScale(scale);
-            pd->m_Transform.position = Vector3f(pos[0], pos[1], pos[2]);
-            // Convert VTK Degrees to internal Radians
-            pd->m_Transform.rotation = Vector3f(ori[0], ori[1], ori[2]) * CLHEP::degree;
-            pd->m_Transform.scaling  = Vector3f(scale[0], scale[1], scale[2]);
+        // 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];
        }
        
-        // Notify puppet properties updated
+        // 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();
@@ -618,7 +572,9 @@ 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, "");
    }
 };

@@ -626,8 +582,10 @@ 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("Opacity", pd->m_Opacity).range(0.0, 1.0).set_default(1.0);
+        ar & boost::serialization::make_hrp("ColorR", pd->m_Color[0]);
+        ar & boost::serialization::make_hrp("ColorG", pd->m_Color[1]);
+        ar & boost::serialization::make_hrp("ColorB", pd->m_Color[2]);
+        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);
--- a/src/Vtk/uLibVtkInterface.h
+++ b/src/Vtk/uLibVtkInterface.h
@@ -38,7 +38,6 @@

 // vtk classes forward declaration //
 class vtkProp;
-class vtkProp3D;
 class vtkPolyData;
 class vtkPropCollection;
 class vtkRenderer;
@@ -122,9 +121,6 @@ protected:

  void RemoveProp(vtkProp *prop);

-  void ApplyAppearance(vtkProp* prop);
-  void ApplyTransform(vtkProp3D* p3d);
-
  std::vector<uLib::PropertyBase*> m_DisplayProperties;
  mutable uLib::RecursiveMutex m_UpdateMutex;

@@ -177,9 +173,6 @@ public:
    void save_override(const boost::serialization::hrp<T> &t) {
        if (m_Puppet) {
            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());
-            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;
            uLib::Object::connect(p, &uLib::PropertyBase::Updated, [puppet](){ puppet->Update(); });
--- a/src/Vtk/vtkHandlerWidget.cpp
+++ b/src/Vtk/vtkHandlerWidget.cpp
@@ -48,8 +48,6 @@
 #include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
-#include "Math/Transform.h"
-#include "Vtk/Math/vtkDense.h"

 namespace uLib {
 namespace Vtk {
@@ -64,23 +62,20 @@ struct HandlerWidgetData {
  vtkSmartPointer<::vtkActor> m_RotCam;                     // Camera ring
  vtkSmartPointer<::vtkActor> m_ScaleX, m_ScaleY, m_ScaleZ; // Cubes

-  // cut plane to see only half of rotation handles
  vtkSmartPointer<::vtkPlane> m_ClipPlane;

-  // picker to select the gizmo
  vtkSmartPointer<::vtkCellPicker> m_Picker;
-
-  // initial transform of the object
  vtkSmartPointer<::vtkTransform> m_InitialTransform;
  
-  // undo stack
-  std::vector<uLib::TRS> m_UndoStack;
+  std::vector<vtkSmartPointer<::vtkTransform>> m_TransformChain;
+  vtkSmartPointer<::vtkMatrix4x4> m_BaseMatrix;

  HandlerWidgetData() {
    m_Picker = vtkSmartPointer<::vtkCellPicker>::New();
    m_InitialTransform = vtkSmartPointer<::vtkTransform>::New();
    m_ClipPlane = vtkSmartPointer<::vtkPlane>::New();
    m_OverlayRenderer = vtkSmartPointer<::vtkRenderer>::New();
+    m_BaseMatrix = vtkSmartPointer<::vtkMatrix4x4>::New();
    m_HighlightedProp = nullptr;
  }
 };
@@ -100,6 +95,7 @@ vtkHandlerWidget::vtkHandlerWidget() : d(new HandlerWidgetData()) {
  this->m_TranslationEnabled = true;
  this->m_RotationEnabled = true;
  this->m_ScalingEnabled = true;
+  d->m_BaseMatrix->Identity();
  this->CreateGizmos();
 }

@@ -112,14 +108,19 @@ vtkHandlerWidget::~vtkHandlerWidget() {
  return d->m_OverlayRenderer;
 }

-
 void vtkHandlerWidget::SetProp3D(::vtkProp3D *prop) {
  if (this->Prop3D == prop) {
    return;
  }
  this->Prop3D = prop;
  if (this->Prop3D) {
-    this->d->m_UndoStack.clear(); // Clear history when selecting new object
+    // Initialize d->m_BaseMatrix from the object's current matrix
+    if (this->Prop3D->GetUserMatrix()) {
+      this->d->m_BaseMatrix->DeepCopy(this->Prop3D->GetUserMatrix());
+    } else {
+      this->d->m_BaseMatrix->Identity();
+    }
+    this->d->m_TransformChain.clear(); // Clear any previous transform chain
    this->UpdateGizmoPosition();
  }
  this->Modified();
@@ -246,19 +247,20 @@ void vtkHandlerWidget::OnKeyPress() {
  bool ctrl = (this->Interactor->GetControlKey() != 0);
  
  if (ctrl && key == "z") {
-    if (!this->d->m_UndoStack.empty()) {
+    if (!this->d->m_TransformChain.empty()) {
      std::cout << "Undoing last transform action..." << std::endl;
-      uLib::TRS target = this->d->m_UndoStack.back();
-      this->d->m_UndoStack.pop_back();
+      this->d->m_TransformChain.pop_back();
      
-      if (this->Prop3D) {
-        this->Prop3D->SetPosition(target.position.x(), target.position.y(), target.position.z());
-        // Convert Model Radians to VTK Degrees
-        this->Prop3D->SetOrientation(target.rotation.x() / CLHEP::degree, 
-                                   target.rotation.y() / CLHEP::degree, 
-                                   target.rotation.z() / CLHEP::degree);
-        this->Prop3D->SetScale(target.scaling.x(), target.scaling.y(), target.scaling.z());
-        this->Prop3D->SetUserMatrix(nullptr);
+      // Update object from chain
+      vtkNew<vtkTransform> total;
+      total->PostMultiply();
+      total->SetMatrix(this->d->m_BaseMatrix.GetPointer());
+      for (auto& t : d->m_TransformChain) {
+        total->Concatenate(t);
+      }
+      
+      if (this->Prop3D && this->Prop3D->GetUserMatrix()) {
+        this->Prop3D->GetUserMatrix()->DeepCopy(total->GetMatrix());
        this->Prop3D->Modified();
        this->UpdateGizmoPosition();
        this->InvokeEvent(::vtkCommand::InteractionEvent, nullptr);
@@ -309,12 +311,21 @@ void vtkHandlerWidget::OnLeftButtonDown() {
    this->StartEventPosition[0] = X;
    this->StartEventPosition[1] = Y;
    if (this->Prop3D) {
-      // Capture current state for Undo
-      this->d->m_UndoStack.push_back(uLib::TRS(uLib::Vtk::VtkToMatrix4f(this->Prop3D->GetMatrix())));
-      if (this->d->m_UndoStack.size() > 50) this->d->m_UndoStack.erase(this->d->m_UndoStack.begin());
+      if (!this->Prop3D->GetUserMatrix()) {
+          vtkNew<vtkMatrix4x4> vmat;
+          this->Prop3D->SetUserMatrix(vmat);
+      }
      
-      // Use the prop's total matrix for calculation baseline
-      this->d->m_InitialTransform->SetMatrix(this->Prop3D->GetMatrix());
+      // If the chain is empty, initialize base from current state?
+      // Actually, if we just started selecting this object, we should have initialized BaseMatrix.
+      // For now, let's keep d->m_InitialTransform as the state BEFORE this drag
+      vtkNew<vtkTransform> current;
+      current->PostMultiply();
+      current->SetMatrix(this->d->m_BaseMatrix.GetPointer());
+      for (auto& t : d->m_TransformChain) {
+        current->Concatenate(t);
+      }
+      this->d->m_InitialTransform->SetMatrix(current->GetMatrix());
    }
    this->EventCallbackCommand->SetAbortFlag(1);
    this->InvokeEvent(::vtkCommand::StartInteractionEvent, nullptr);
@@ -326,6 +337,27 @@ void vtkHandlerWidget::OnLeftButtonUp() {
  if (this->Interaction == IDLE)
    return;

+  // Finalize the current interaction into the chain
+  int X = this->Interactor->GetEventPosition()[0];
+  int Y = this->Interactor->GetEventPosition()[1];
+  
+  // We need to re-calculate the final 'op' to store it
+  // Actually, we could have stored it in OnMouseMove, but let's re-calculate or 
+  // just capture the delta between d->m_InitialTransform and current UserMatrix.
+  if (this->Prop3D && this->Prop3D->GetUserMatrix()) {
+      vtkNew<vtkMatrix4x4> inv;
+      vtkMatrix4x4::Invert(this->d->m_InitialTransform->GetMatrix(), inv);
+      
+      vtkNew<vtkMatrix4x4> final_op_mat;
+      vtkMatrix4x4::Multiply4x4(this->Prop3D->GetUserMatrix(), inv, final_op_mat);
+      
+      vtkNew<vtkTransform> final_op;
+      final_op->SetMatrix(final_op_mat);
+      
+      this->d->m_TransformChain.push_back(final_op);
+      std::cout << "Action finalized. Chain size: " << this->d->m_TransformChain.size() << std::endl;
+  }
+
  this->Interaction = IDLE;
  this->EventCallbackCommand->SetAbortFlag(1);
  this->InvokeEvent(::vtkCommand::EndInteractionEvent, nullptr);
@@ -546,17 +578,9 @@ void vtkHandlerWidget::OnMouseMove() {
  total->SetMatrix(this->d->m_InitialTransform->GetMatrix()); // d->m_InitialTransform is already Base*Chain
  total->Concatenate(op);

-  if (this->Prop3D) {
-      double p[3], r[3], s[3];
-      total->GetPosition(p);
-      total->GetOrientation(r);
-      total->GetScale(s);
-      this->Prop3D->SetPosition(p);
-      // VTK GetOrientation already returned degrees, so r is in degrees.
-      // We apply it directly back to VTK.
-      this->Prop3D->SetOrientation(r);
-      this->Prop3D->SetScale(s);
-      this->Prop3D->SetUserMatrix(nullptr);
+  vtkMatrix4x4* targetMat = this->Prop3D->GetUserMatrix();
+  if (targetMat) {
+      targetMat->DeepCopy(total->GetMatrix());
  }
  
  this->Prop3D->Modified();
@@ -647,7 +671,7 @@ void vtkHandlerWidget::SetTransform(::vtkTransform *t) {
 void vtkHandlerWidget::GetTransform(::vtkTransform *t) {
  if (!t || !this->Prop3D)
    return;
-  t->SetMatrix(this->Prop3D->GetMatrix());
+  t->SetMatrix(this->Prop3D->GetUserMatrix());
 }

 void vtkHandlerWidget::CreateGizmos() {
--- a/src/Vtk/vtkObjectsContext.cpp
+++ b/src/Vtk/vtkObjectsContext.cpp
@@ -110,16 +110,17 @@ void vtkObjectsContext::Update() {
 Puppet* vtkObjectsContext::CreatePuppet(uLib::Object* obj) {
  if (!obj) return nullptr;

-  if (auto* box = dynamic_cast<uLib::ContainerBox*>(obj)) {
-    return new vtkContainerBox(box);
-  } else if (auto* chamber = dynamic_cast<uLib::DetectorChamber*>(obj)) {
-    return new vtkDetectorChamber(chamber);
-  } else if (auto* cylinder = dynamic_cast<uLib::Cylinder*>(obj)) {
-    return new vtkCylinder(cylinder);
-  } else if (auto* vox = dynamic_cast<uLib::Abstract::VoxImage*>(obj)) {
-    return new vtkVoxImage(*vox);
-  } else if (auto* assembly = dynamic_cast<uLib::Assembly*>(obj)) {
-    return new Assembly(assembly);
+  const char* className = obj->GetClassName();
+  if (std::strcmp(className, "ContainerBox") == 0) {
+    return new vtkContainerBox(static_cast<uLib::ContainerBox*>(obj));
+  } else if (std::strcmp(className, "DetectorChamber") == 0) {
+    return new vtkDetectorChamber(static_cast<uLib::DetectorChamber*>(obj));
+  } else if (std::strcmp(className, "Cylinder") == 0) {
+    return new vtkCylinder(static_cast<uLib::Cylinder*>(obj));
+  } else if (std::strcmp(className, "VoxImage") == 0) {
+    return new vtkVoxImage(*static_cast<uLib::Abstract::VoxImage*>(obj));
+  } else if (std::strcmp(className, "Assembly") == 0) {
+    return new Assembly(static_cast<uLib::Assembly*>(obj));
  }
  
  // Fallback if we don't know the exact class but it might be a context itself
--- a/src/Vtk/Math/vtkPolydata.cpp
+++ b/src/Vtk/Math/vtkPolydata.cpp
--- a/src/Vtk/Math/vtkPolydata.h
+++ b/src/Vtk/Math/vtkPolydata.h
--- a/src/Vtk/vtkViewport.cpp
+++ b/src/Vtk/vtkViewport.cpp
@@ -209,6 +209,7 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
            for (auto* p : self->m_Puppets) {
                if (p->IsSelected()) {
                    p->SyncFromVtk();
+                    p->Update();
                }
            }
        });
--- a/src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.cpp
+++ b/src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.cpp
@@ -25,11 +25,27 @@



-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#ifndef U_VTKULIBPROP_H
+#define U_VTKULIBPROP_H

-#include <Vtk/vtkMuonContainerScattering.h>
+class vtkProp;
+
+namespace uLib {
+namespace Abstract {
+
+class uLibVtkProp {
+public:
+    virtual vtkProp *GetProp() = 0;
+
+protected:
+    ~uLibVtkProp() {}
+};


-// TO BE CONTINUED //
+
+
+}
+
+}
+
+#endif // VTKULIBPROP_H
Author	SHA1	Message	Date
AndreaRigoni	876b8f4592	algorithm chain for ram-vram	2026-03-28 08:22:14 +00:00
AndreaRigoni	ec2027e980	check if algorithm could be run on cuda	2026-03-27 16:42:04 +00:00
AndreaRigoni	69b47623f8	algorithm on filters	2026-03-27 02:45:40 +00:00
AndreaRigoni	f5c1e317e8	algorithm def	2026-03-27 02:29:56 +00:00