feat: add NotifyPropertiesUpdated to Object and trigger on Transform changes for UI synchronization

.agents/rules/micromamba.md

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

.clangd

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

.vscode/settings.json

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

CMakeLists.txt

@@ -21,7 +21,7 @@ endif()
 project(uLib)
 
 # CUDA Toolkit seems to be missing locally. Toggle ON if nvcc is made available.
-option(USE_CUDA "Enable CUDA support" ON)
+option(USE_CUDA "Enable CUDA support" OFF)
 if(USE_CUDA)
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -allow-unsupported-compiler")
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
@@ -115,7 +115,7 @@ set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
 message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
 
-find_package(HDF5 REQUIRED CONFIG)
+find_package(HDF5 REQUIRED)
 
 find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
 include_directories(${Boost_INCLUDE_DIRS})

CMakePresets.json

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

app/gcompose/src/ContextModel.cpp

@@ -4,6 +4,11 @@
 #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) {}
@@ -11,12 +16,16 @@ 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);
@@ -25,7 +34,6 @@ 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();
         });
 
@@ -35,6 +43,7 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
         }
     }
     endResetModel();
+    m_isReseting = false;
 }
 
 QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent) const {
@@ -48,8 +57,8 @@ QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent)
         }
     } else {
         uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
-        uLib::ObjectsContext* parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
+        uLib::ObjectsContext* parentCtx = parentObj->GetChildren();
-        if (parentCtx && row < parentCtx->GetCount()) {
+        if (parentCtx && row < (int)parentCtx->GetCount()) {
             return createIndex(row, column, parentCtx->GetObject(row));
         }
     }
@@ -65,36 +74,37 @@ 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::ObjectsContext*(uLib::ObjectsContext*, uLib::Object*)> findParent = 
+    std::function<uLib::Object*(uLib::Object*, uLib::Object*)> findParent = 
-        [&findParent](uLib::ObjectsContext* ctx, uLib::Object* target) -> uLib::ObjectsContext* {
+        [&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 ctx;
+                if (obj == target) return current;
-            if (auto subCtx = dynamic_cast<uLib::ObjectsContext*>(obj)) {
+                if (auto p = findParent(obj, target)) return p;
-                if (auto p = findParent(subCtx, target)) return p;
             }
         }
         return nullptr;
     };
 
-    uLib::ObjectsContext* parentCtx = findParent(m_rootContext, childObj);
+    uLib::Object* parentObj = findParent(m_rootContext, childObj);
-    if (!parentCtx || parentCtx == m_rootContext) {
+    if (!parentObj || parentObj == m_rootContext) {
         return QModelIndex(); // Root items have invalid parent index
     }
 
-    // Now need to find the row of parentCtx in its own parent Context.
+    // Now need to find the row of parentObj in its own parent Context.
-    uLib::ObjectsContext* grandParentCtx = findParent(m_rootContext, parentCtx);
+    uLib::Object* grandParentObj = findParent(m_rootContext, parentObj);
-    if (!grandParentCtx) grandParentCtx = m_rootContext;
+    uLib::ObjectsContext* grandParentCtx = grandParentObj ? grandParentObj->GetChildren() : m_rootContext;
 
     int row = -1;
     for (size_t i = 0; i < grandParentCtx->GetCount(); ++i) {
-        if (grandParentCtx->GetObject(i) == parentCtx) {
+        if (grandParentCtx->GetObject(i) == parentObj) {
             row = (int)i;
             break;
         }
     }
 
     if (row != -1) {
-        return createIndex(row, 0, parentCtx);
+        return createIndex(row, 0, parentObj);
     }
     return QModelIndex();
 }
@@ -107,8 +117,8 @@ int ContextModel::rowCount(const QModelIndex& parent) const {
     }
 
     uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
-    if (auto parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj)) {
+    if (auto parentCtx = parentObj->GetChildren()) {
-        return parentCtx->GetCount();
+        return (int)parentCtx->GetCount();
     }
     return 0; // leaf node
 }
@@ -161,8 +171,98 @@ QVariant ContextModel::headerData(int section, Qt::Orientation orientation, int
 }
 
 Qt::ItemFlags ContextModel::flags(const QModelIndex& index) const {
-    if (!index.isValid()) return Qt::NoItemFlags;
+    if (!index.isValid()) return m_rootContext ? Qt::ItemIsDropEnabled : Qt::NoItemFlags;
-    return Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
+    
+    Qt::ItemFlags f = Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
+    uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+    if (dynamic_cast<uLib::ObjectsContext*>(obj)) {
+        f |= Qt::ItemIsDropEnabled;
+    }
+    return f;
+}
+
+Qt::DropActions ContextModel::supportedDropActions() const {
+    return Qt::MoveAction;
+}
+
+QStringList ContextModel::mimeTypes() const {
+    return {"application/x-ulib-object-ptr"};
+}
+
+QMimeData* ContextModel::mimeData(const QModelIndexList& indexes) const {
+    QMimeData* mimeData = new QMimeData();
+    QByteArray encodedData;
+    QDataStream stream(&encodedData, QIODevice::WriteOnly);
+    for (const auto& idx : indexes) {
+        if (idx.isValid() && idx.column() == 0) {
+            void* ptr = idx.internalPointer();
+            stream << reinterpret_cast<qlonglong>(ptr);
+        }
+    }
+    mimeData->setData("application/x-ulib-object-ptr", encodedData);
+    return mimeData;
+}
+
+bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) {
+    if (action != Qt::MoveAction || !data->hasFormat("application/x-ulib-object-ptr")) return false;
+
+    uLib::ObjectsContext* targetCtx = m_rootContext;
+    if (parent.isValid()) {
+        uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+        targetCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
+    }
+    if (!targetCtx) return false;
+
+    QByteArray encodedData = data->data("application/x-ulib-object-ptr");
+    QDataStream stream(&encodedData, QIODevice::ReadOnly);
+    std::vector<uLib::Object*> objectsToMove;
+    while (!stream.atEnd()) {
+        qlonglong ptrVal;
+        stream >> ptrVal;
+        objectsToMove.push_back(reinterpret_cast<uLib::Object*>(ptrVal));
+    }
+
+    if (objectsToMove.empty()) return false;
+
+    // Helper to find and remove from current parent
+    std::function<void(uLib::Object*, uLib::Object*)> findAndRemoveRecursive = 
+        [&findAndRemoveRecursive](uLib::Object* current, uLib::Object* target) {
+        if (auto ctx = current->GetChildren()) {
+            ctx->RemoveObject(target);
+            for (auto* obj : ctx->GetObjects()) {
+                findAndRemoveRecursive(obj, target);
+            }
+        }
+    };
+
+    m_isReseting = true;
+    beginResetModel();
+    for (auto* obj : objectsToMove) {
+        // Don't drop onto itself or its descendants
+        bool invalid = (obj == targetCtx || obj == (uLib::Object*)targetCtx);
+        if (!invalid) {
+             // check if targetCtx is descendant of obj
+             std::function<bool(uLib::Object*, uLib::Object*)> isDescendant = 
+                [&isDescendant](uLib::Object* root, uLib::Object* target) -> bool {
+                 if (auto ctx = root->GetChildren()) {
+                     for (auto* child : ctx->GetObjects()) {
+                         if (child == target) return true;
+                         if (isDescendant(child, target)) return true;
+                     }
+                 }
+                 return false;
+             };
+             if (isDescendant(obj, (uLib::Object*)targetCtx)) invalid = true;
+        }
+        
+        if (!invalid) {
+            findAndRemoveRecursive(m_rootContext, obj);
+            targetCtx->AddObject(obj);
+        }
+    }
+    endResetModel();
+    m_isReseting = false;
+    return true;
 }
 
 bool ContextModel::setData(const QModelIndex& index, const QVariant& value, int role) {

app/gcompose/src/ContextModel.h

@@ -21,8 +21,15 @@ public:
     Qt::ItemFlags flags(const QModelIndex& index) const override;
     bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
 
+    // Drag and Drop support
+    Qt::DropActions supportedDropActions() const override;
+    QStringList mimeTypes() const override;
+    QMimeData* mimeData(const QModelIndexList& indexes) const override;
+    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
+
 private:
     uLib::ObjectsContext* m_rootContext;
+    bool m_isReseting = false;
 };
 
 #endif // CONTEXT_MODEL_H

app/gcompose/src/ContextPanel.cpp

@@ -38,6 +38,10 @@ ContextPanel::ContextPanel(QWidget* parent)
     m_treeView = new QTreeView(this);
     m_treeView->setObjectName("ContextTree");
     m_treeView->setHeaderHidden(false);
+    m_treeView->setDragEnabled(true);
+    m_treeView->setAcceptDrops(true);
+    m_treeView->setDropIndicatorShown(true);
+    m_treeView->setDragDropMode(QAbstractItemView::DragDrop);
     
     m_model = new ContextModel(this);
     m_treeView->setModel(m_model);

app/gcompose/src/PropertyWidgets.cpp

@@ -7,6 +7,11 @@
 #include "Vtk/uLibVtkInterface.h"
 #include "Math/Units.h"
 #include "Math/Dense.h"
+#include <QPushButton>
+#include <QColorDialog>
+#include <QFrame>
+#include <QSlider>
+#include "Settings.h"
 
 namespace uLib {
 namespace Qt {
@@ -15,8 +20,21 @@ PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent)
     : QWidget(parent), m_BaseProperty(prop) {
     m_Layout = new QHBoxLayout(this);
     m_Layout->setContentsMargins(4, 2, 4, 2);
-    m_Label = new QLabel(QString::fromStdString(prop->GetName()), this);
+    
-    m_Label->setMinimumWidth(100);
+    std::string unit = prop->GetUnits();
+    QString labelText = QString::fromStdString(prop->GetName());
+    if (!unit.empty() && unit != "color") {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        if (!pref.empty()) {
+            labelText += " [" + QString::fromStdString(pref) + "]";
+        } else {
+            labelText += " [" + QString::fromStdString(unit) + "]";
+        }
+    }
+    
+    m_Label = new QLabel(labelText, this);
+    m_Label->setMinimumWidth(120);
     m_Layout->addWidget(m_Label);
 }
 PropertyWidgetBase::~PropertyWidgetBase() {
@@ -31,7 +49,7 @@ double parseWithUnits(const QString& text, double* factorOut, QString* suffixOut
 
     double num = match.captured(1).toDouble();
     QString unit = match.captured(3);
-    double factor = 1.0;
+    double factor = factorOut ? *factorOut : 1.0;
 
     if (!unit.isEmpty()) {
         QString u = unit.startsWith('_') ? unit.mid(1) : unit;
@@ -87,10 +105,6 @@ 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);
     }
@@ -115,9 +129,6 @@ void UnitLineEdit::updateText() {
             s += ".0";
         }
     }
-    if (!m_Suffix.isEmpty()) {
-        s += " " + m_Suffix;
-    }
     setText(s);
 }
 
@@ -129,11 +140,12 @@ void UnitLineEdit::setIntegerOnly(bool integerOnly) {
 DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* parent)
     : PropertyWidgetBase(prop, parent), m_Prop(prop) {
     m_Edit = new UnitLineEdit(this);
-    QString units = QString::fromStdString(prop->GetUnits());
+    std::string unit = prop->GetUnits();
-    if (!units.isEmpty()) {
+    if (!unit.empty()) {
-        double factor = 1.0;
+        auto dim = Settings::Instance().IdentifyDimension(unit);
-        parseWithUnits("1 " + units, &factor);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
-        m_Edit->setUnits(units, factor);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
     }
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
@@ -146,11 +158,12 @@ DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* pare
 FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
     : PropertyWidgetBase(prop, parent), m_Prop(prop) {
     m_Edit = new UnitLineEdit(this);
-    QString units = QString::fromStdString(prop->GetUnits());
+    std::string unit = prop->GetUnits();
-    if (!units.isEmpty()) {
+    if (!unit.empty()) {
-        double factor = 1.0;
+        auto dim = Settings::Instance().IdentifyDimension(unit);
-        parseWithUnits("1 " + units, &factor);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
-        m_Edit->setUnits(units, factor);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
     }
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
@@ -164,11 +177,12 @@ IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
     : PropertyWidgetBase(prop, parent), m_Prop(prop) {
     m_Edit = new UnitLineEdit(this);
     m_Edit->setIntegerOnly(true);
-    QString units = QString::fromStdString(prop->GetUnits());
+    std::string unit = prop->GetUnits();
-    if (!units.isEmpty()) {
+    if (!unit.empty()) {
-        double factor = 1.0;
+        auto dim = Settings::Instance().IdentifyDimension(unit);
-        parseWithUnits("1 " + units, &factor);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
-        m_Edit->setUnits(units, factor);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
     }
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
@@ -193,6 +207,76 @@ 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);
@@ -211,6 +295,26 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
 }
 StringPropertyWidget::~StringPropertyWidget() {}
 
+class GroupHeaderWidget : public QWidget {
+public:
+    GroupHeaderWidget(const QString& name, QWidget* parent = nullptr) : QWidget(parent) {
+        auto* layout = new QVBoxLayout(this);
+        layout->setContentsMargins(0, 8, 0, 4);
+        auto* line = new QFrame(this);
+        line->setFrameShape(QFrame::HLine);
+        line->setFrameShadow(QFrame::Sunken);
+        line->setStyleSheet("color: #555;");
+        layout->addWidget(line);
+        auto* label = new QLabel(name, this);
+        QFont font = label->font();
+        font.setBold(true);
+        font.setPointSize(font.pointSize() + 1);
+        label->setFont(font);
+        label->setStyleSheet("color: #aaa; text-transform: uppercase;");
+        layout->addWidget(label);
+    }
+};
+
 class EnumPropertyWidget : public PropertyWidgetBase {
     PropertyBase* m_Prop;
     QComboBox* m_Combo;
@@ -305,26 +409,63 @@ void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
         }
     }
 
+    // Group properties by their group string
+    std::map<std::string, std::vector<::uLib::PropertyBase*>> groupedProps;
+    std::vector<std::string> groupOrder;
+    
     for (auto* prop : *props) {
-        // Priority 1: Check if it provides enum labels
+        std::string group = prop->GetGroup();
-        if (!prop->GetEnumLabels().empty()) {
+        if (groupedProps.find(group) == groupedProps.end()) {
-            m_ContainerLayout->addWidget(new EnumPropertyWidget(prop, m_Container));
+            groupOrder.push_back(group);
-            continue;
+        }
+        groupedProps[group].push_back(prop);
     }
 
+    for (const auto& groupName : groupOrder) {
+        if (!groupName.empty()) {
+            m_ContainerLayout->addWidget(new GroupHeaderWidget(QString::fromStdString(groupName), m_Container));
+        }
+
+        for (auto* prop : groupedProps[groupName]) {
+            QWidget* widget = nullptr;
+            
+            // Priority 1: Check if it provides enum labels
+            if (!prop->GetEnumLabels().empty()) {
+                widget = new EnumPropertyWidget(prop, m_Container);
+            } else if (prop->GetUnits() == "color") {
+                // Color Picker for Vector3d
+                if (auto* pvec = dynamic_cast<Property<Vector3d>*>(prop)) {
+                    widget = new ColorPropertyWidget(pvec, m_Container);
+                }
+            } else if (prop->HasRange()) {
+                // Slider for ranged doubles
+                if (auto* pdbl = dynamic_cast<Property<double>*>(prop)) {
+                    widget = new RangePropertyWidget(pdbl, m_Container);
+                } else if (auto* pflt = dynamic_cast<Property<float>*>(prop)) {
+                     // widget = new RangePropertyWidget<float>(pflt, m_Container);
+                }
+            } else {
                 // Priority 2: Standard factory lookup
                 auto it = m_Factories.find(prop->GetTypeIndex());
                 if (it != m_Factories.end()) {
-            QWidget* widget = it->second(prop, m_Container);
+                    widget = it->second(prop, m_Container);
-            m_ContainerLayout->addWidget(widget);
                 } else {
                     // Debug info for unknown types
-            std::cout << "PropertyEditor: No factory for " << prop->GetName() 
+                    std::cout << "PropertyEditor: No factory for " << prop->GetQualifiedName() 
                               << " (Type: " << prop->GetTypeName() << ")" << std::endl;
 
-            QWidget* fallback = new PropertyWidgetBase(prop, m_Container);
+                    widget = new PropertyWidgetBase(prop, m_Container);
-            fallback->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
+                    widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
-            m_ContainerLayout->addWidget(fallback);
+                }
+            }
+
+            if (widget) {
+                if (!groupName.empty()) {
+                    // Indent grouped properties
+                    widget->setContentsMargins(16, 0, 0, 0);
+                }
+                m_ContainerLayout->addWidget(widget);
+            }
         }
     }
     m_ContainerLayout->addStretch(1);

app/gcompose/src/PropertyWidgets.h

@@ -2,6 +2,8 @@
 #define PROPERTY_WIDGETS_H
 
 #include <QWidget>
+class QPushButton;
+class QSlider;
 #include <QLabel>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
@@ -16,6 +18,7 @@
 #include "Core/Object.h"
 #include "Core/Signal.h"
 #include "Math/Dense.h"
+#include "Settings.h"
 
 namespace uLib {
 namespace Qt {
@@ -93,18 +96,24 @@ class VectorPropertyWidget : public PropertyWidgetBase {
 public:
     VectorPropertyWidget(Property<VecT>* prop, QWidget* parent = nullptr)
         : PropertyWidgetBase(prop, parent), m_Prop(prop) {
-        QString units = QString::fromStdString(prop->GetUnits());
+        
+        std::string unit = prop->GetUnits();
         double factor = 1.0;
-        if (!units.isEmpty()) {
+        QString prefSuffix;
-            parseWithUnits("1 " + units, &factor);
+        if (!unit.empty()) {
+            auto dim = Settings::Instance().IdentifyDimension(unit);
+            std::string pref = Settings::Instance().GetPreferredUnit(dim);
+            factor = Settings::Instance().GetUnitFactor(pref);
+            prefSuffix = QString::fromStdString(pref);
         }
+
         for (int i = 0; i < Size; ++i) {
             m_Edits[i] = new UnitLineEdit(this);
             if (std::is_integral<typename VecT::Scalar>::value) {
                 m_Edits[i]->setIntegerOnly(true);
             }
-            if (!units.isEmpty()) {
+            if (!prefSuffix.isEmpty()) {
-               m_Edits[i]->setUnits(units, factor);
+               m_Edits[i]->setUnits(prefSuffix, factor);
             }
             m_Layout->addWidget(m_Edits[i], 1);
             
@@ -134,6 +143,20 @@ 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:
@@ -144,6 +167,19 @@ 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:

app/gcompose/src/Settings.h

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

app/gcompose/src/ViewportPane.cpp

@@ -46,23 +46,25 @@ ViewportPane::ViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullpt
 
     m_layout->addWidget(m_titleBar);
 
-    // Main horizontal container for viewport and display panel
+    // Main area with splitter for viewport and display panel
-    QWidget* mainArea = new QWidget(this);
+    m_areaSplitter = new QSplitter(Qt::Horizontal, this);
-    QHBoxLayout* hLayout = new QHBoxLayout(mainArea);
+    m_areaSplitter->setObjectName("ViewportAreaSplitter");
-    hLayout->setContentsMargins(0, 0, 0, 0);
+    m_layout->addWidget(m_areaSplitter, 1);
-    hLayout->setSpacing(0);
-    m_layout->addWidget(mainArea);
 
     // Viewport will be added here via setViewport
-    m_viewport = new uLib::Vtk::QViewport(mainArea);
+    m_viewport = new uLib::Vtk::QViewport(m_areaSplitter);
-    hLayout->addWidget(m_viewport);
+    m_areaSplitter->addWidget(m_viewport);
 
     // Display Panel (Overlay/Slide-out)
-    m_displayPanel = new QFrame(mainArea);
+    m_displayPanel = new QFrame(m_areaSplitter);
     m_displayPanel->setObjectName("DisplayPropertiesPanel");
-    m_displayPanel->setFixedWidth(250);
+    m_displayPanel->setMinimumWidth(150);
     m_displayPanel->hide();
     
+    m_areaSplitter->addWidget(m_displayPanel);
+    m_areaSplitter->setStretchFactor(0, 1);
+    m_areaSplitter->setStretchFactor(1, 0);
+    
     QVBoxLayout* panelLayout = new QVBoxLayout(m_displayPanel);
     panelLayout->setContentsMargins(5, 5, 5, 5);
     
@@ -73,8 +75,6 @@ ViewportPane::ViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullpt
     m_displayEditor = new uLib::Qt::PropertyEditor(m_displayPanel);
     panelLayout->addWidget(m_displayEditor);
 
-    hLayout->addWidget(m_displayPanel);
-
     connect(m_toggleBtn, &QPushButton::toggled, this, &ViewportPane::toggleDisplayPanel);
     connect(m_titleBar, &QWidget::customContextMenuRequested, this, &ViewportPane::showContextMenu);
     connect(closeBtn, &QToolButton::clicked, this, &ViewportPane::onCloseRequested);
@@ -85,7 +85,15 @@ ViewportPane::ViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullpt
 ViewportPane::~ViewportPane() {}
 
 void ViewportPane::toggleDisplayPanel() {
-    m_displayPanel->setVisible(m_toggleBtn->isChecked());
+    bool visible = m_toggleBtn->isChecked();
+    m_displayPanel->setVisible(visible);
+    if (visible && m_areaSplitter->sizes().value(1, 0) == 0) {
+        QList<int> sizes = m_areaSplitter->sizes();
+        int total = sizes[0] + sizes[1];
+        sizes[1] = 250;
+        sizes[0] = total - 250;
+        m_areaSplitter->setSizes(sizes);
+    }
 }
 
 void ViewportPane::setObject(uLib::Object* obj) {
@@ -107,15 +115,14 @@ void ViewportPane::setObject(uLib::Object* obj) {
 
 void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
     if (m_viewport) {
-        m_viewport->parentWidget()->layout()->removeWidget(m_viewport);
         delete m_viewport;
     }
     m_viewport = viewport;
     m_titleLabel->setText(title);
 
     m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-    auto* mainAreaLayout = static_cast<QHBoxLayout*>(m_displayPanel->parentWidget()->layout());
+    m_areaSplitter->insertWidget(0, m_viewport);
-    mainAreaLayout->insertWidget(0, m_viewport);
+    m_areaSplitter->setStretchFactor(0, 1);
 }
 
 void ViewportPane::addVtkViewport() {

app/gcompose/src/ViewportPane.h

@@ -10,6 +10,7 @@ namespace uLib {
     namespace Qt { class PropertyEditor; }
 }
 
+class QSplitter;
 class QVBoxLayout;
 class QLabel;
 
@@ -39,6 +40,7 @@ private:
     QVBoxLayout* m_layout;
     QWidget* m_titleBar;
     QLabel* m_titleLabel;
+    QSplitter* m_areaSplitter;
     QWidget* m_viewport;
 
     // Display Properties Overlay

docs/update_properties.md

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

src/Core/Debug.h

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

src/Core/Object.cpp

@@ -90,14 +90,19 @@ const std::vector<PropertyBase*>& Object::GetProperties() const {
 
 PropertyBase* Object::GetProperty(const std::string& name) const {
     for (auto* p : d->m_Properties) {
-        if (p->GetName() == name) return p;
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
     }
     for (auto* p : d->m_DynamicProperties) {
-        if (p->GetName() == name) return p;
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
     }
     return nullptr;
 }
 
+void Object::NotifyPropertiesUpdated() {
+    for (auto* p : d->m_Properties) p->Updated();
+    for (auto* p : d->m_DynamicProperties) p->Updated();
+}
+
 // In Object.h, the template serialize needs to be updated to call property serialization.
 // However, since Object::serialize is a template in the header, we might need a helper here.
 

src/Core/Object.h

@@ -52,6 +52,7 @@ class polymorphic_oarchive;
 namespace uLib {
 
 class PropertyBase;
+class ObjectsContext;
 
 class Version {
 public:
@@ -95,12 +96,18 @@ public:
   const std::vector<PropertyBase*>& GetProperties() const;
   PropertyBase* GetProperty(const std::string& name) const;
 
+  /** @brief Sends an Updated signal for all properties of this object. useful for real-time UI refresh. */
+  void NotifyPropertiesUpdated();
+
   ////////////////////////////////////////////////////////////////////////////
   // PARAMETERS //
 
   // FIXX !!!
   virtual void DeepCopy(const Object &copy);
 
+  /** @brief Returns a nested context for children objects, if any. */
+  virtual ObjectsContext* GetChildren() { return nullptr; }
+
   ////////////////////////////////////////////////////////////////////////////
   // SERIALIZATION //
 
@@ -129,6 +136,7 @@ public:
 
   signals:
   virtual void Updated();
+  virtual void PropertyUpdated();
 
   // Qt4 style connector //
   static bool connect(const Object *ob1, const char *signal_name,

src/Core/ObjectsContext.h

@@ -9,12 +9,13 @@ namespace uLib {
 /**
  * @brief ObjectsContext represents a collection of Object instances.
  */
-class ObjectsContext : public Object {
+class ObjectsContext : virtual 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.

src/Core/Property.h

@@ -2,11 +2,16 @@
 #define U_CORE_PROPERTY_H
 
 #include <string>
+#include <vector>
 #include <sstream>
 #include <typeinfo>
 #include <typeindex> // Added
 #include <boost/serialization/nvp.hpp>
 #include <boost/lexical_cast.hpp>
+#include <vector>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/serialization/serialization.hpp>
 #include "Core/Archives.h"
 #include "Core/Signal.h"
 #include "Core/Object.h"
@@ -29,6 +34,19 @@ public:
       static std::vector<std::string> empty;
       return empty;
   }
+  virtual const std::string& GetGroup() const = 0;
+  virtual void SetGroup(const std::string& group) = 0;
+
+  virtual bool HasRange() const { return false; }
+  virtual double GetMin() const { return 0; }
+  virtual double GetMax() const { return 0; }
+  virtual bool HasDefault() const { return false; }
+  virtual std::string GetDefaultValueAsString() const { return ""; }
+
+  std::string GetQualifiedName() const {
+      if (GetGroup().empty()) return GetName();
+      return GetGroup() + "." + GetName();
+  }
 
   // Signal support
   signals:
@@ -51,16 +69,18 @@ template <typename T>
 class Property : public PropertyBase {
 public:
   // PROXY: Use an existing variable as back-end storage
-  Property(Object* owner, const std::string& name, T* valuePtr, const std::string& units = "")
+  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_value(valuePtr), m_own(false) {
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(valuePtr), m_own(false),
+      m_HasRange(false), m_HasDefault(false) {
       if (m_owner) {
           m_owner->RegisterProperty(this);
       }
   }
 
   // MANAGED: Create and own internal storage
-  Property(Object* owner, const std::string& name, const T& defaultValue = T(), const std::string& units = "")
+  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_value(new T(defaultValue)), m_own(true) {
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(new T(defaultValue)), m_own(true),
+      m_HasRange(false), m_HasDefault(true), m_Default(defaultValue) {
       if (m_owner) {
           m_owner->RegisterProperty(this);
       }
@@ -76,6 +96,8 @@ public:
   virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(T)); }
   virtual const std::string& GetUnits() const override { return m_units; }
   virtual void SetUnits(const std::string& units) override { m_units = units; }
+  virtual const std::string& GetGroup() const override { return m_group; }
+  virtual void SetGroup(const std::string& group) override { m_group = group; }
 
   
   std::string GetValueAsString() const override {
@@ -90,15 +112,61 @@ 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) {
-    if (*m_value != value) {
+    T val = value;
-      *m_value = value;
+    ValidateT<T>(val);
+    if (*m_value != val) {
+      *m_value = val;
       ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
       this->Updated();
       if (m_owner) m_owner->Updated();
     }
   }
 
+  void SetRange(const T& min, const T& max) { m_Min = min; m_Max = max; m_HasRange = true; }
+  void SetDefault(const T& def) { m_Default = def; m_HasDefault = true; }
+
+  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) {
@@ -124,12 +192,23 @@ 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;
+  std::string m_group;
   T* m_value;
   bool m_own;
   Object* m_owner;
+  bool m_HasRange;
+  T m_Min;
+  T m_Max;
+  bool m_HasDefault;
+  T m_Default;
 };
 
 /**
@@ -149,8 +228,8 @@ typedef Property<Bool_t>      BoolProperty;
  */
 class EnumProperty : public Property<int> {
 public:
-  EnumProperty(Object* owner, const std::string& name, int* valuePtr, const std::vector<std::string>& labels, const std::string& units = "")
+  EnumProperty(Object* owner, const std::string& name, int* valuePtr, const std::vector<std::string>& labels, const std::string& units = "", const std::string& group = "")
-    : Property<int>(owner, name, valuePtr, units), m_Labels(labels) {}
+    : Property<int>(owner, name, valuePtr, units, group), m_Labels(labels) {}
 
   const std::vector<std::string>& GetEnumLabels() const override { return m_Labels; }
   const char* GetTypeName() const override { return "Enum"; }
@@ -209,11 +288,22 @@ public:
         boost::archive::detail::common_oarchive<property_register_archive>(boost::archive::no_header),
         m_Object(obj) {}
     
+    std::string GetCurrentGroup() const {
+        std::string group;
+        for (const auto& g : m_GroupStack) {
+            if (!group.empty()) group += ".";
+            group += g;
+        }
+        return group;
+    }
+
     // Core logic: encounter HRP -> Create Dynamic Property
     template<class T>
     void save_override(const boost::serialization::hrp<T> &t) {
         if (m_Object) {
-            Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp<T>&>(t).value(), t.units() ? t.units() : "");
+            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);
         }
     }
@@ -221,7 +311,7 @@ public:
     template<class T>
     void save_override(const boost::serialization::hrp_enum<T> &t) {
         if (m_Object) {
-            EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum<T>&>(t).value(), t.labels(), t.units() ? t.units() : "");
+            EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
             m_Object->RegisterDynamicProperty(p);
         }
     }
@@ -229,11 +319,24 @@ public:
     // Handle standard NVPs by recursing (important for base classes)
     template<class T>
     void save_override(const boost::serialization::nvp<T> &t) {
-        boost::archive::detail::common_oarchive<property_register_archive>::save_override(t.const_value());
+        if (t.name()) m_GroupStack.push_back(t.name());
+        this->save_helper(t.const_value(), typename boost::is_class<T>::type());
+        if (t.name()) m_GroupStack.pop_back();
     }
 
-    // Ignore everything else
+    // Recursion for nested classes, ignore primitives
-    template<class T> void save_override(const T &t) {}
+    template<class T>
+    void save_override(const T &t) {
+        this->save_helper(t, typename boost::is_class<T>::type());
+    }
+
+    template<class T>
+    void save_helper(const T &t, boost::mpl::true_) {
+        boost::serialization::serialize_adl(*this, const_cast<T&>(t), 0);
+    }
+
+    template<class T>
+    void save_helper(const T &t, boost::mpl::false_) {}
 
     // Required attribute overrides for common_oarchive
     void save_override(const boost::archive::object_id_type & t) {}
@@ -244,6 +347,9 @@ public:
     void save_override(const boost::archive::class_id_reference_type & t) {}
     void save_override(const boost::archive::class_name_type & t) {}
     void save_override(const boost::archive::tracking_type & t) {}
+
+private:
+    std::vector<std::string> m_GroupStack;
 };
 
 /**

src/Core/Serializable.h

@@ -77,15 +77,30 @@ 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) {}
+  explicit hrp(const char *name_, T &t, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_has_range(false), m_has_default(false) {}
+
+  hrp& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
+  hrp& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
 
   const char *name() const { return this->m_name; }
   const char *units() const { return this->m_units; }
   T &value() { return this->m_value; }
   const T &const_value() const { return this->m_value; }
 
+  bool has_range() const { return m_has_range; }
+  const T& min_val() const { return m_min; }
+  const T& max_val() const { return m_max; }
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
   BOOST_SERIALIZATION_SPLIT_MEMBER()
 
   template <class Archivex>
@@ -110,16 +125,23 @@ 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_name(name_), m_units(units_), m_value(t), m_labels(labels), m_has_default(false) {}
+
+  hrp_enum& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
 
   const char *name() const { return this->m_name; }
   const char *units() const { return this->m_units; }
   T &value() { return this->m_value; }
   const std::vector<std::string>& labels() const { return m_labels; }
 
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
   BOOST_SERIALIZATION_SPLIT_MEMBER()
 
   template <class Archivex>

src/Core/Signal.h

@@ -95,6 +95,8 @@ namespace uLib {
 
 typedef boost::signals2::signal_base SignalBase;
 typedef boost::signals2::connection Connection;
+typedef boost::signals2::shared_connection_block ConnectionBlock;
+
 
 template <typename T> struct Signal {
   typedef boost::signals2::signal<T> type;

src/Core/testing/CMakeLists.txt

@@ -23,6 +23,7 @@ set( TESTS
         VectorMetaAllocatorTest
         PropertyTypesTest
         HRPTest
+        PropertyGroupingTest
         MutexTest
         ThreadsTest
         OpenMPTest

src/Core/testing/PropertyGroupingTest.cpp

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

src/Core/testing/testing-prototype.h

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

src/HEP/Geant/EmitterPrimary.hh

@@ -23,7 +23,7 @@ class G4Event;
 namespace uLib {
 namespace Geant {
 
-class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public Object, public AffineTransform
+class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransform
 {
   public:
 

src/Math/Assembly.cpp

@@ -21,27 +21,45 @@ namespace uLib {
 
 Assembly::Assembly()
     : ObjectsContext(),
-      AffineTransform(),
+      TRS(),
       m_BBoxMin(Vector3f::Zero()),
       m_BBoxMax(Vector3f::Zero()),
       m_ShowBoundingBox(false),
-      m_GroupSelection(true) {}
+      m_GroupSelection(true) {
+    ULIB_ACTIVATE_PROPERTIES(*this);
+}
 
 Assembly::Assembly(const Assembly &copy)
     : ObjectsContext(copy),
-      AffineTransform(copy),
+      TRS(copy),
       m_BBoxMin(copy.m_BBoxMin),
       m_BBoxMax(copy.m_BBoxMax),
       m_ShowBoundingBox(copy.m_ShowBoundingBox),
       m_GroupSelection(copy.m_GroupSelection) {}
 
-Assembly::~Assembly() {}
+Assembly::~Assembly() {
+    for (auto const& [obj, conn] : m_ChildConnections) {
+        conn.disconnect();
+    }
+    m_ChildConnections.clear();
+}
 
 void Assembly::AddObject(Object *obj) {
     if (auto *at = dynamic_cast<AffineTransform *>(obj)) {
         at->SetParent(this);
     }
     ObjectsContext::AddObject(obj);
+    
+    // Connect to child updates to recompute AABB
+    m_ChildConnections[obj] = Object::connect(obj, &Object::Updated, [this](){
+        this->ComputeBoundingBox();
+        this->Updated(); // Signal that assembly itself changed (AABB-wise)
+    });
+
+    // Parent -> Child propagation for world matrix updates
+    Object::connect(this, &Object::Updated, obj, &Object::Updated);
+
+    this->ComputeBoundingBox();
 }
 
 void Assembly::RemoveObject(Object *obj) {
@@ -49,7 +67,15 @@ 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() {
@@ -64,12 +90,11 @@ 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 assembly base
+            // ContainerBox: wm is matrix from unit cube [0,1] to local space
-            Matrix4f m = invAsm * box->GetWorldMatrix();
+            // Since it is parented to 'this', GetMatrix() is sufficient.
+            Matrix4f m = box->GetMatrix();
             for (int i = 0; i < 8; ++i) {
                 float x = (i & 1) ? 1.0f : 0.0f;
                 float y = (i & 2) ? 1.0f : 0.0f;
@@ -82,7 +107,7 @@ void Assembly::ComputeBoundingBox() {
             }
         } else if (auto *cyl = dynamic_cast<Cylinder *>(obj)) {
             // Cylinder: centered [-1, 1] radial, [-0.5, 0.5] height
-            Matrix4f m = invAsm * cyl->GetWorldMatrix();
+            Matrix4f m = cyl->GetMatrix();
             for (int i = 0; i < 8; ++i) {
                 float x = (i & 1) ? 1.0f : -1.0f;
                 float y = (i & 2) ? 0.5f : -0.5f;
@@ -98,7 +123,7 @@ void Assembly::ComputeBoundingBox() {
             subAsm->ComputeBoundingBox();
             Vector3f subMin, subMax;
             subAsm->GetBoundingBox(subMin, subMax);
-            Matrix4f m = invAsm * subAsm->GetWorldMatrix();
+            Matrix4f m = subAsm->GetMatrix();
             for (int i = 0; i < 8; ++i) {
                 float x = (i & 1) ? subMax(0) : subMin(0);
                 float y = (i & 2) ? subMax(1) : subMin(1);

src/Math/Assembly.h

@@ -43,14 +43,21 @@ namespace uLib {
  * A bounding box is automatically computed from all contained objects and
  * can be queried or shown/hidden through the VTK puppet.
  */
-class Assembly : public ObjectsContext, public AffineTransform {
+class Assembly : public ObjectsContext, public TRS {
 public:
+    uLibTypeMacro(Assembly, ObjectsContext, TRS)
     virtual const char *GetClassName() const override { return "Assembly"; }
 
     Assembly();
     Assembly(const Assembly &copy);
     virtual ~Assembly();
 
+    template <class ArchiveT>
+    void serialize(ArchiveT & ar, const unsigned int version) {
+        ar & boost::serialization::make_nvp("TRS", boost::serialization::base_object<TRS>(*this));
+        ar & boost::serialization::make_hrp("GroupSelection", m_GroupSelection);
+    }
+
     virtual void AddObject(Object* obj) override;
     virtual void RemoveObject(Object* obj) override;
 
@@ -89,10 +96,13 @@ public:
 
 signals:
     virtual void Updated() override {
-        if (m_InUpdated) return;  // break signal recursion
+        if (m_InUpdated) return; 
         m_InUpdated = true;
+        
+        // Synchronize TRS part
+        this->TRS::Updated();
+        
         this->ComputeBoundingBox();
-        ULIB_SIGNAL_EMIT(Assembly::Updated);
         m_InUpdated = false;
     }
 
@@ -102,6 +112,7 @@ private:
     bool     m_ShowBoundingBox;
     bool     m_GroupSelection;
     bool     m_InUpdated = false;
+    std::map<Object*, Connection> m_ChildConnections;
 };
 
 } // namespace uLib

src/Math/ContainerBox.h

@@ -33,27 +33,31 @@
 #include "Math/Transform.h"
 #include <utility>
 
+#include <iostream>
+
 namespace uLib {
 
 /**
  * @brief Represents an oriented bounding box (OBB) within a hierarchical
  * transformation system.
  *
- * ContainerBox inherits from AffineTransform, which defines its parent
+ * ContainerBox inherits from TRS, which defines its parent
  * coordinate system. It contains an internal local transformation (m_LocalT)
  * that defines the box's specific origin and size relative to its own
  * coordinate system.
  */
-class ContainerBox : public AffineTransform, public Object {
+class ContainerBox : public TRS {
-
-  typedef AffineTransform BaseClass;
 
 public:
+  uLibTypeMacro(ContainerBox, TRS)
+
+  virtual const char * GetClassName() const override { return "ContainerBox"; }
+
   ////////////////////////////////////////////////////////////////////////////
   // PROPERTIES //
-  Property<Vector3f> p_Size;
+  
-  Property<Vector3f> p_Origin;
+  Vector3f Size;
-  virtual const char * GetClassName() const { return "ContainerBox"; }
+  Vector3f Origin;
 
   /**
    * @brief Default constructor.
@@ -61,10 +65,10 @@ public:
    */
   ContainerBox()
       : m_LocalT(this), // BaseClass is Parent of m_LocalTransform
-        p_Size(this, "Size", Vector3f(1.0f, 1.0f, 1.0f)),
+        Size(1.0f, 1.0f, 1.0f),
-        p_Origin(this, "Origin", Vector3f(0.0f, 0.0f, 0.0f)) {
+        Origin(0.0f, 0.0f, 0.0f) {
-    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
+    ULIB_ACTIVATE_PROPERTIES(*this);
-    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
+    this->Sync();
   }
 
   /**
@@ -73,11 +77,10 @@ public:
    */
   ContainerBox(const Vector3f &size)
       : m_LocalT(this),
-        p_Size(this, "Size", size),
+        Size(size),
-        p_Origin(this, "Origin", Vector3f(0.0f, 0.0f, 0.0f)) {
+        Origin(0.0f, 0.0f, 0.0f) {
-    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
+    ULIB_ACTIVATE_PROPERTIES(*this);
-    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
+    this->Sync();
-    this->SetSize(size);
   }
 
   /**
@@ -85,13 +88,22 @@ public:
    * @param copy The ContainerBox instance to copy from.
    */
   ContainerBox(const ContainerBox &copy)
-      : m_LocalT(copy.m_LocalT), // Copy local transform state
+      : m_LocalT(this), // Reset parent to the new object
-        AffineTransform(copy),
+        TRS(copy),
-        p_Size(this, "Size", copy.p_Size),
+        Size(copy.Size),
-        p_Origin(this, "Origin", copy.p_Origin) {
+        Origin(copy.Origin) {
-    m_LocalT.SetParent(this); // Reset parent to the new object
+    ULIB_ACTIVATE_PROPERTIES(*this);
-    Object::connect(&p_Size, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncSize);
+    this->Sync();
-    Object::connect(&p_Origin, &Property<Vector3f>::PropertyChanged, this, &ContainerBox::SyncOrigin);
+  }
+
+  /**
+   * @brief Serialization template for property registration and persistence.
+   */
+  template <class ArchiveT>
+  void serialize(ArchiveT & ar, const unsigned int version) {
+    ar & HRP(Size);
+    ar & HRP(Origin);
+    ar & boost::serialization::make_nvp("TRS", boost::serialization::base_object<TRS>(*this));
   }
 
   /**
@@ -99,7 +111,7 @@ public:
    * @param v The origin position vector.
    */
   void SetOrigin(const Vector3f &v) { 
-    p_Origin = v;
+    Origin = v;
     m_LocalT.SetPosition(v); 
   }
 
@@ -115,7 +127,7 @@ public:
    * @param v The size vector (width, height, depth).
    */
   void SetSize(const Vector3f &v) {
-    p_Size = v;
+    Size = v;
     Vector3f pos = this->GetOrigin();
     m_LocalT = AffineTransform(this); // regenerate local transform
     m_LocalT.Scale(v);
@@ -194,26 +206,32 @@ public:
   }
 
   /** Translate using transformation chain */
-  using BaseClass::Translate;
+  using AffineTransform::Translate;
 
   /** Rotate using transformation chain */
-  using BaseClass::Rotate;
+  using AffineTransform::Rotate;
 
   /** Scale using transformation chain */
-  using BaseClass::Scale;
+  using AffineTransform::Scale;
 
 signals:
 
-  // signal to emit when the box is updated //
+  /** Signal emitted when properties change */
-  virtual void Updated() override { ULIB_SIGNAL_EMIT(ContainerBox::Updated); }
+  virtual void Updated() override { 
+      // 1. Synchronize local box part (Size/Origin -> m_LocalT)
+      this->Sync();
       
-private slots:
+      // 2. Synchronize TRS part (position/rotation/scaling -> m_T) and emit signal
-  void SyncSize() {
+      this->TRS::Updated();
-      this->SetSize(p_Size);
+      
+      // std::cout << "ContainerBox::Updated()" << std::endl;
   }
 
-  void SyncOrigin() {
+private:
-      this->SetOrigin(p_Origin);
+  /** Synchronizes internal transformation with properties */
+  void Sync() {
+      this->SetOrigin(Origin);
+      this->SetSize(Size);
   }
 
 

src/Math/Cylinder.h

@@ -39,10 +39,17 @@ 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, public Object {
+class Cylinder : public TRS {
 
 public:
-    uLibTypeMacro(Cylinder, Object)
+    uLibTypeMacro(Cylinder, TRS)
+
+    /**
+     * @brief PROPERTIES
+     */
+    float Radius;
+    float Height;
+    int Axis;
 
     virtual const char * GetClassName() const override { return "Cylinder"; }
 
@@ -51,7 +58,7 @@ public:
      */
     Cylinder() : m_LocalT(this), Radius(1.0), Height(1.0), Axis(1) {
         ULIB_ACTIVATE_PROPERTIES(*this);
-        UpdateLocalMatrix();
+        this->Sync();
     }
 
     /**
@@ -60,16 +67,16 @@ public:
     Cylinder(float radius, float height, int axis = 1) 
         : m_LocalT(this), Radius(radius), Height(height), Axis(axis) {
         ULIB_ACTIVATE_PROPERTIES(*this);
-        UpdateLocalMatrix();
+        this->Sync();
     }
 
     /**
      * @brief Copy constructor.
      */
     Cylinder(const Cylinder &copy)
-        : m_LocalT(this), AffineTransform(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
+        : m_LocalT(this), TRS(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
         ULIB_ACTIVATE_PROPERTIES(*this);
-        this->UpdateLocalMatrix();
+        this->Sync();
     }
 
     /**
@@ -77,6 +84,7 @@ public:
      */
     template <class ArchiveT>
     void serialize(ArchiveT & ar, const unsigned int version) {
+        ar & boost::serialization::make_nvp("TRS", boost::serialization::base_object<TRS>(*this));
         ar & HRP(Radius);
         ar & HRP(Height);
         ar & HRP(Axis);
@@ -85,7 +93,7 @@ public:
     /** Sets the radius of the cylinder */
     inline void SetRadius(float r) { 
         Radius = r; 
-        UpdateLocalMatrix(); 
+        this->Sync(); 
     }
     
     /** Gets the radius of the cylinder */
@@ -94,7 +102,7 @@ public:
     /** Sets the height of the cylinder */
     inline void SetHeight(float h) { 
         Height = h; 
-        UpdateLocalMatrix(); 
+        this->Sync(); 
     }
     
     /** Gets the height of the cylinder */
@@ -103,7 +111,7 @@ public:
     /** Sets the main axis (0=X, 1=Y, 2=Z) */
     inline void SetAxis(int axis) {
         Axis = axis;
-        UpdateLocalMatrix();
+        this->Sync();
     }
 
     /** Gets the main axis */
@@ -157,25 +165,36 @@ 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->UpdateLocalMatrix();
+        // 1. Synchronize local cylinder part (Radius/Height/Axis -> m_LocalT)
-        ULIB_SIGNAL_EMIT(Cylinder::Updated); 
+        this->Sync();
+        
+        // 2. Synchronize TRS part (position/rotation/scaling -> m_T) and emit signal
+        this->TRS::Updated();
     }
 
 private:
-    /** Recalculates the internal local matrix based on dimensions and axis */
+  /** Synchronizes internal transformation with properties */
-    void UpdateLocalMatrix() {
+  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));
   }
 
-    float Radius;
+
-    float Height;
+private:
-    int Axis;
     AffineTransform m_LocalT;
 };
 

src/Math/Geometry.h

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

src/Math/MathRegistrations.cpp

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

src/Math/QuadMesh.h

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

src/Math/Transform.h

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

src/Math/TriangleMesh.h

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

src/Math/VoxImageFilter.hpp

@@ -98,15 +98,14 @@ template <typename T> void Kernel<T>::PrintSelf(std::ostream &o) const {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#define _TPL_ template <typename VoxelT, typename AlgorithmT>
-#define _TPLT_ VoxelT, AlgorithmT
 
-_TPL_
+
-VoxImageFilter<_TPLT_>::VoxImageFilter(const Vector3i &size)
+template <typename VoxelT, typename AlgorithmT>
+VoxImageFilter<VoxelT, AlgorithmT>::VoxImageFilter(const Vector3i &size)
     : m_KernelData(size), t_Algoritm(static_cast<AlgorithmT *>(this)) {}
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<_TPLT_>::Run() {
+void VoxImageFilter<VoxelT, AlgorithmT>::Run() {
   VoxImage<VoxelT> buffer = *m_Image;
 #pragma omp parallel for
   for (int i = 0; i < m_Image->Data().size(); ++i)
@@ -114,8 +113,8 @@ void VoxImageFilter<_TPLT_>::Run() {
 #pragma omp barrier
 }
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<_TPLT_>::SetKernelOffset() {
+void VoxImageFilter<VoxelT, AlgorithmT>::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,8 +126,8 @@ void VoxImageFilter<_TPLT_>::SetKernelOffset() {
   }
 }
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v) {
+float VoxImageFilter<VoxelT, AlgorithmT>::Distance2(const Vector3i &v) {
   Vector3i tmp = v;
   const Vector3i &dim = this->m_KernelData.GetDims();
   Vector3i center = dim / 2;
@@ -140,8 +139,8 @@ float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v) {
                  0.25 * (3 - (dim(0) % 2) - (dim(1) % 2) - (dim(2) % 2)));
 }
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(
+void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelNumericXZY(
     const std::vector<float> &numeric) {
   // set data order //
   StructuredData::Order order = m_KernelData.GetDataOrder();
@@ -159,8 +158,8 @@ void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(
   // m_KernelData.SetDataOrder(order);
 }
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<_TPLT_>::SetKernelSpherical(float (*shape)(float)) {
+void VoxImageFilter<VoxelT, AlgorithmT>::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) {
@@ -172,8 +171,8 @@ void VoxImageFilter<_TPLT_>::SetKernelSpherical(float (*shape)(float)) {
   }
 }
 
-_TPL_ template <class ShapeT>
+template <typename VoxelT, typename AlgorithmT> template <class ShapeT>
-void VoxImageFilter<_TPLT_>::SetKernelSpherical(ShapeT shape) {
+void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelSpherical(ShapeT shape) {
   Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
   Vector3i id;
   for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
@@ -186,8 +185,8 @@ void VoxImageFilter<_TPLT_>::SetKernelSpherical(ShapeT shape) {
   }
 }
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(
+void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(
     float (*shape)(const Vector3f &)) {
   const Vector3i &dim = m_KernelData.GetDims();
   Vector3i id;
@@ -207,8 +206,8 @@ void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(
   }
 }
 
-_TPL_ template <class ShapeT>
+template <typename VoxelT, typename AlgorithmT> template <class ShapeT>
-void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(ShapeT shape) {
+void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(ShapeT shape) {
   Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
   const Vector3i &dim = m_KernelData.GetDims();
   Vector3i id;
@@ -228,14 +227,14 @@ void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(ShapeT shape) {
   }
 }
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-void VoxImageFilter<_TPLT_>::SetImage(Abstract::VoxImage *image) {
+void VoxImageFilter<VoxelT, AlgorithmT>::SetImage(Abstract::VoxImage *image) {
   this->m_Image = reinterpret_cast<VoxImage<VoxelT> *>(image);
   this->SetKernelOffset();
 }
 
-_TPL_
+template <typename VoxelT, typename AlgorithmT>
-float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer,
+float VoxImageFilter<VoxelT, AlgorithmT>::Convolve(const VoxImage<VoxelT> &buffer,
                                        int index) {
   const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
   const DataAllocator<VoxelT> &vker = m_KernelData.ConstData();
@@ -252,8 +251,8 @@ float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer,
   return conv / ksum;
 }
 
-#undef _TPLT_
+
-#undef _TPL_
+
 
 } // namespace uLib
 

src/Math/testing/GeometryTest.cpp

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

src/Math/testing/testing-prototype.h

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

src/Python/math_bindings.cpp

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

src/Vtk/CMakeLists.txt

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

src/Vtk/HEP/Detectors/vtkDetectorChamber.cxx

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

src/Vtk/HEP/Detectors/vtkDetectorChamber.h

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

src/Vtk/HEP/Detectors/vtkMuonEvent.h

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

src/Vtk/HEP/Detectors/vtkMuonScatter.cxx

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

src/Vtk/HEP/Detectors/vtkMuonScatter.h

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

src/Vtk/HEP/Geant/vtkGeantEvent.h

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

src/Vtk/HEP/Geant/vtkGeantSolid.h

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

src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.cpp

@@ -25,27 +25,11 @@
 
 
 
-#ifndef U_VTKULIBPROP_H
+#ifdef HAVE_CONFIG_H
-#define U_VTKULIBPROP_H
+#include "config.h"
+#endif
 
-class vtkProp;
+#include <Vtk/vtkMuonContainerScattering.h>
-
-namespace uLib {
-namespace Abstract {
-
-class uLibVtkProp {
-public:
-    virtual vtkProp *GetProp() = 0;
-
-protected:
-    ~uLibVtkProp() {}
-};
 
 
-
+// TO BE CONTINUED //
-
-}
-
-}
-
-#endif // VTKULIBPROP_H

src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.h

@@ -0,0 +1,74 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+#ifndef VTKMUONCONTAINERSCATTERING_H
+#define VTKMUONCONTAINERSCATTERING_H
+
+
+
+#include "Math/Dense.h"
+
+#include "uLibVtkInterface.h"
+#include "Detectors/MuonScatter.h"
+
+class vtkRenderWindowInteractor;
+
+namespace uLib {
+
+class vtkMuonContainerScattering : public Abstract::uLibVtkPolydata {
+    typedef MuonScatter Content;
+public:
+    vtkMuonContainerScattering(const MuonScatter &content);
+    ~vtkMuonScatter();
+
+    Content& GetContent();
+
+    void PrintSelf(std::ostream &o) const;
+
+    virtual vtkProp *GetProp();
+
+    virtual vtkPolyData* GetPolyData() const;
+
+    void AddPocaPoint(HPoint3f poca);
+
+    HPoint3f GetPocaPoint();
+
+    void vtkStartInteractive();
+
+protected:
+    void ConnectInteractor(vtkRenderWindowInteractor *interactor);
+
+private:
+    void InstallPipe();
+
+};
+
+
+}
+
+
+#endif // VTKMUONCONTAINERSCATTERING_H

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.cpp

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

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h

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

src/Vtk/Math/CMakeLists.txt

@@ -11,6 +11,7 @@ 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
@@ -22,6 +23,7 @@ set(MATH_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkContainerBox.h
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkCylinder.h
     ${CMAKE_CURRENT_SOURCE_DIR}/vtkAssembly.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkPolydata.h
     PARENT_SCOPE)
 
 if(BUILD_TESTING)

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

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

src/Vtk/Math/vtkAssembly.cpp

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

src/Vtk/Math/vtkAssembly.h

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

src/Vtk/Math/vtkContainerBox.cpp

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

src/Vtk/Math/vtkContainerBox.h

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

src/Vtk/Math/vtkCylinder.cpp

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

src/Vtk/Math/vtkCylinder.h

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

src/Vtk/Math/vtkQuadMesh.h

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

src/Vtk/Math/vtkTriangleMesh.h

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

src/Vtk/Math/vtkVoxImage.cpp

@@ -124,6 +124,7 @@ void vtkVoxImage::SetContent() {
 
 vtkVoxImage::vtkVoxImage(Content &content)
     : m_Content(content), m_Actor(vtkVolume::New()),
+      m_Asm(vtkAssembly::New()),
       m_Image(vtkImageData::New()), m_Outline(vtkCubeSource::New()),
       m_OutlineActor(vtkActor::New()),
       m_Reader(NULL), m_Writer(NULL), writer_factor(1.E6),
@@ -136,6 +137,7 @@ vtkVoxImage::vtkVoxImage(Content &content)
 vtkVoxImage::~vtkVoxImage() {
   m_Image->Delete();
   m_Actor->Delete();
+  m_Asm->Delete();
   m_Outline->Delete();
   m_OutlineActor->Delete();
 }
@@ -330,8 +332,9 @@ void vtkVoxImage::InstallPipe() {
   m_OutlineActor->GetProperty()->SetRepresentationToWireframe();
   m_OutlineActor->GetProperty()->SetAmbient(0.7);
 
-  this->SetProp(m_Actor);
+  m_Asm->AddPart(m_Actor);
-  this->SetProp(m_OutlineActor);
+  m_Asm->AddPart(m_OutlineActor);
+  this->SetProp(m_Asm);
   
   // Default look
   this->SetRepresentation(Surface);

src/Vtk/Math/vtkVoxImage.h

@@ -31,6 +31,7 @@
 #include <vtkVolume.h>
 #include <vtkXMLImageDataReader.h>
 #include <vtkXMLImageDataWriter.h>
+#include <vtkAssembly.h>
 
 #include <Math/VoxImage.h>
 
@@ -77,6 +78,7 @@ private:
   vtkImageData *m_Image;
   vtkCubeSource *m_Outline;
   vtkActor *m_OutlineActor;
+  vtkAssembly *m_Asm;
 
   vtkXMLImageDataReader *m_Reader;
   vtkXMLImageDataWriter *m_Writer;

src/Vtk/testing/CMakeLists.txt

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

src/Vtk/testing/PuppetParentingTest.cpp

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

src/Vtk/testing/testing-prototype.h

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

src/Vtk/uLibVtkInterface.cxx

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

src/Vtk/uLibVtkInterface.h

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

src/Vtk/vtkHandlerWidget.cpp

@@ -48,6 +48,8 @@
 #include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
+#include "Math/Transform.h"
+#include "Vtk/Math/vtkDense.h"
 
 namespace uLib {
 namespace Vtk {
@@ -62,20 +64,23 @@ 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;
   
-  std::vector<vtkSmartPointer<::vtkTransform>> m_TransformChain;
+  // undo stack
-  vtkSmartPointer<::vtkMatrix4x4> m_BaseMatrix;
+  std::vector<uLib::TRS> m_UndoStack;
 
   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;
   }
 };
@@ -95,7 +100,6 @@ vtkHandlerWidget::vtkHandlerWidget() : d(new HandlerWidgetData()) {
   this->m_TranslationEnabled = true;
   this->m_RotationEnabled = true;
   this->m_ScalingEnabled = true;
-  d->m_BaseMatrix->Identity();
   this->CreateGizmos();
 }
 
@@ -108,19 +112,14 @@ vtkHandlerWidget::~vtkHandlerWidget() {
   return d->m_OverlayRenderer;
 }
 
+
 void vtkHandlerWidget::SetProp3D(::vtkProp3D *prop) {
   if (this->Prop3D == prop) {
     return;
   }
   this->Prop3D = prop;
   if (this->Prop3D) {
-    // Initialize d->m_BaseMatrix from the object's current matrix
+    this->d->m_UndoStack.clear(); // Clear history when selecting new object
-    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();
@@ -247,20 +246,19 @@ void vtkHandlerWidget::OnKeyPress() {
   bool ctrl = (this->Interactor->GetControlKey() != 0);
   
   if (ctrl && key == "z") {
-    if (!this->d->m_TransformChain.empty()) {
+    if (!this->d->m_UndoStack.empty()) {
       std::cout << "Undoing last transform action..." << std::endl;
-      this->d->m_TransformChain.pop_back();
+      uLib::TRS target = this->d->m_UndoStack.back();
+      this->d->m_UndoStack.pop_back();
       
-      // Update object from chain
+      if (this->Prop3D) {
-      vtkNew<vtkTransform> total;
+        this->Prop3D->SetPosition(target.position.x(), target.position.y(), target.position.z());
-      total->PostMultiply();
+        // Convert Model Radians to VTK Degrees
-      total->SetMatrix(this->d->m_BaseMatrix.GetPointer());
+        this->Prop3D->SetOrientation(target.rotation.x() / CLHEP::degree, 
-      for (auto& t : d->m_TransformChain) {
+                                   target.rotation.y() / CLHEP::degree, 
-        total->Concatenate(t);
+                                   target.rotation.z() / CLHEP::degree);
-      }
+        this->Prop3D->SetScale(target.scaling.x(), target.scaling.y(), target.scaling.z());
-      
+        this->Prop3D->SetUserMatrix(nullptr);
-      if (this->Prop3D && this->Prop3D->GetUserMatrix()) {
-        this->Prop3D->GetUserMatrix()->DeepCopy(total->GetMatrix());
         this->Prop3D->Modified();
         this->UpdateGizmoPosition();
         this->InvokeEvent(::vtkCommand::InteractionEvent, nullptr);
@@ -311,21 +309,12 @@ void vtkHandlerWidget::OnLeftButtonDown() {
     this->StartEventPosition[0] = X;
     this->StartEventPosition[1] = Y;
     if (this->Prop3D) {
-      if (!this->Prop3D->GetUserMatrix()) {
+      // Capture current state for Undo
-          vtkNew<vtkMatrix4x4> vmat;
+      this->d->m_UndoStack.push_back(uLib::TRS(uLib::Vtk::VtkToMatrix4f(this->Prop3D->GetMatrix())));
-          this->Prop3D->SetUserMatrix(vmat);
+      if (this->d->m_UndoStack.size() > 50) this->d->m_UndoStack.erase(this->d->m_UndoStack.begin());
-      }
 
-      // If the chain is empty, initialize base from current state?
+      // Use the prop's total matrix for calculation baseline
-      // Actually, if we just started selecting this object, we should have initialized BaseMatrix.
+      this->d->m_InitialTransform->SetMatrix(this->Prop3D->GetMatrix());
-      // 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);
@@ -337,27 +326,6 @@ 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);
@@ -578,9 +546,15 @@ void vtkHandlerWidget::OnMouseMove() {
   total->SetMatrix(this->d->m_InitialTransform->GetMatrix()); // d->m_InitialTransform is already Base*Chain
   total->Concatenate(op);
 
-  vtkMatrix4x4* targetMat = this->Prop3D->GetUserMatrix();
+  if (this->Prop3D) {
-  if (targetMat) {
+      vtkNew<vtkMatrix4x4> result;
-      targetMat->DeepCopy(total->GetMatrix());
+      total->GetMatrix(result); 
+      this->Prop3D->SetUserMatrix(result);
+      
+      // Reset individual TRS components so UserMatrix is the single source of truth
+      this->Prop3D->SetPosition(0, 0, 0);
+      this->Prop3D->SetOrientation(0, 0, 0);
+      this->Prop3D->SetScale(1, 1, 1);
   }
   
   this->Prop3D->Modified();
@@ -671,7 +645,7 @@ void vtkHandlerWidget::SetTransform(::vtkTransform *t) {
 void vtkHandlerWidget::GetTransform(::vtkTransform *t) {
   if (!t || !this->Prop3D)
     return;
-  t->SetMatrix(this->Prop3D->GetUserMatrix());
+  t->SetMatrix(this->Prop3D->GetMatrix());
 }
 
 void vtkHandlerWidget::CreateGizmos() {

src/Vtk/vtkObjectsContext.cpp

@@ -107,20 +107,25 @@ void vtkObjectsContext::Update() {
   }
 }
 
+void vtkObjectsContext::SyncFromVtk() {
+  for (auto const& [obj, puppet] : m_Puppets) {
+    puppet->SyncFromVtk();
+  }
+}
+
 Puppet* vtkObjectsContext::CreatePuppet(uLib::Object* obj) {
   if (!obj) return nullptr;
 
-  const char* className = obj->GetClassName();
+  if (auto* box = dynamic_cast<uLib::ContainerBox*>(obj)) {
-  if (std::strcmp(className, "ContainerBox") == 0) {
+    return new vtkContainerBox(box);
-    return new vtkContainerBox(static_cast<uLib::ContainerBox*>(obj));
+  } else if (auto* chamber = dynamic_cast<uLib::DetectorChamber*>(obj)) {
-  } else if (std::strcmp(className, "DetectorChamber") == 0) {
+    return new vtkDetectorChamber(chamber);
-    return new vtkDetectorChamber(static_cast<uLib::DetectorChamber*>(obj));
+  } else if (auto* cylinder = dynamic_cast<uLib::Cylinder*>(obj)) {
-  } else if (std::strcmp(className, "Cylinder") == 0) {
+    return new vtkCylinder(cylinder);
-    return new vtkCylinder(static_cast<uLib::Cylinder*>(obj));
+  } else if (auto* vox = dynamic_cast<uLib::Abstract::VoxImage*>(obj)) {
-  } else if (std::strcmp(className, "VoxImage") == 0) {
+    return new vtkVoxImage(*vox);
-    return new vtkVoxImage(*static_cast<uLib::Abstract::VoxImage*>(obj));
+  } else if (auto* assembly = dynamic_cast<uLib::Assembly*>(obj)) {
-  } else if (std::strcmp(className, "Assembly") == 0) {
+    return new Assembly(assembly);
-    return new Assembly(static_cast<uLib::Assembly*>(obj));
   }
   
   // Fallback if we don't know the exact class but it might be a context itself

src/Vtk/vtkObjectsContext.h

@@ -30,6 +30,9 @@ public:
   /** @brief Updates all managed puppets. */
   virtual void Update() override;
 
+  /** @brief Synchronizes all managed puppets back to their models. */
+  virtual void SyncFromVtk() override;
+
   public:
   virtual void PuppetAdded(Puppet* puppet);
   virtual void PuppetRemoved(Puppet* puppet);

src/Vtk/vtkViewport.cpp

@@ -209,7 +209,6 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
             for (auto* p : self->m_Puppets) {
                 if (p->IsSelected()) {
                     p->SyncFromVtk();
-                    p->Update();
                 }
             }
         });
@@ -506,11 +505,11 @@ void Viewport::SelectPuppet(Puppet* prop)
     
     if (pv->m_HandlerWidget) {
         if (prop) {
-            vtkProp3D* prop3d = vtkProp3D::SafeDownCast(prop->GetProp());
+            vtkProp3D* prop3d = prop->GetProxyProp();
             if (prop3d) {
                 pv->m_HandlerWidget->SetProp3D(prop3d);
                 pv->m_HandlerWidget->SetEnabled(1);
-                pv->m_HandlerWidget->PlaceWidget(prop3d->GetBounds());
+                pv->m_HandlerWidget->PlaceWidget(prop3d->GetBounds()); //TODO: FIX !
             }
         } else {
             pv->m_HandlerWidget->SetEnabled(0);