refactor: add override specifier to type_name method in Core/Types.h

Merges all work from andrea-geo branch:
- Geant material management classes
- Serialization enhancements (read-only, NVP/HRP macros)
- Transform/assembly system improvements
- VTK puppet/viewport updates (orthographic toggle, voxel rendering)
- Property grouping, dynamic properties, NotifyPropertiesUpdated
- Object type identification via uLibTypeMacro
- New tests (PropertyGrouping, ReadOnly, vtkQViewport, PuppetParenting)
- Various gcompose UI fixes

Conflict resolved in CMakePresets.json: kept both 'fast' (clang/lld)
and 'mutom' (stub) presets.

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

.agents/rules/context_exclude_vtk.md

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

.agents/rules/context_gcompose.md

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

.agents/rules/context_vtk.md

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

.agents/rules/micromamba.md

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

.agents/skills/micromamba_build.md

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

.gitignore

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

.vscode/gdb_wrapper.sh

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

.vscode/launch.json

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

.vscode/tasks.json

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

CLAUDE.md

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

CMakeLists.txt

@@ -15,20 +15,11 @@ if(POLICY CMP0167)
     cmake_policy(SET CMP0167 NEW)
 endif()
 
+
 ## -------------------------------------------------------------------------- ##
 
 project(uLib)
 
-# Applica la flag SOLO se il compilatore è GCC
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    add_compile_options(-fno-merge-constants)
-endif()
-
-# Disabilita il warning se il compilatore è Clang (o AppleClang)
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    add_compile_options(-Wno-ignored-optimization-argument)
-endif()
-
 # CUDA Toolkit seems to be missing locally. Toggle ON if nvcc is made available.
 option(USE_CUDA "Enable CUDA support" OFF)
 if(USE_CUDA)
@@ -133,8 +124,6 @@ find_package(Eigen3 CONFIG REQUIRED)
 get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
 include_directories(${EIGEN3_INCLUDE_DIRS})
 
-find_package(OpenMP)
-
 find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
 
@@ -156,8 +145,6 @@ else()
                                 IOXML
                                 IOXMLParser
                                 ImagingCore
-                                ImagingHybrid
-                                ImagingSources
                                 InteractionStyle
                                 InteractionWidgets
                                 RenderingAnnotation

README.md

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

app/gcompose/src/MainPanel.cpp

@@ -90,13 +90,13 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
     
     connect(m_contextPanel, &ContextPanel::objectSelected, [this](uLib::Object* obj) {
         if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
-            uLib::Vtk::Prop3D* prop3d = nullptr;
+            uLib::Vtk::Puppet* puppet = nullptr;
             if (m_mainVtkContext) {
-                prop3d = m_mainVtkContext->GetProp3D(obj);
+                puppet = m_mainVtkContext->GetPuppet(obj);
             }
-            viewport->SelectProp3D(prop3d);
+            viewport->SelectPuppet(puppet);
-            // Update the display properties in the viewport pane itself - use the prop3d proxy if possible
+            // Update the display properties in the viewport pane itself - use the puppet proxy if possible
-            m_firstPane->setObject(prop3d ? (uLib::Object*)prop3d : obj);
+            m_firstPane->setObject(puppet ? (uLib::Object*)puppet : obj);
         } else {
             m_firstPane->setObject(obj);
         }
@@ -116,7 +116,7 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
 
     if (m_mainVtkContext) {
         if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
-            viewport->RemoveProp3D(*m_mainVtkContext);
+            viewport->RemovePuppet(*m_mainVtkContext);
         }
         delete m_mainVtkContext;
         m_mainVtkContext = nullptr;
@@ -124,10 +124,10 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
 
     if (context) {
         if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
-            m_mainVtkContext = new uLib::Vtk::ObjectsContext(context);
+            m_mainVtkContext = new uLib::Vtk::vtkObjectsContext(context);
-            // viewport->AddProp3D(*m_mainVtkContext); // redundant
+            // viewport->AddPuppet(*m_mainVtkContext); // redundant
 
-            auto syncSelection = [this](uLib::Vtk::Prop3D* p) {
+            auto syncSelection = [this](uLib::Vtk::Puppet* p) {
                 if (!p) {
                     m_contextPanel->clearSelection();
                     m_firstPane->setObject(nullptr);
@@ -136,14 +136,14 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
                     m_firstPane->setObject(p);
                 }
             };
-            connect(viewport, &uLib::Vtk::QViewport::prop3dSelected, syncSelection);
+            connect(viewport, &uLib::Vtk::QViewport::puppetSelected, syncSelection);
 
-            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::ObjectsContext::Prop3DAdded, [this](uLib::Vtk::Prop3D* p) {
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetAdded, [this](uLib::Vtk::Puppet* p) {
                 if (p) {
                     auto panes = this->findChildren<ViewportPane*>();
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
-                            vp->AddProp3D(*p);
+                            vp->AddPuppet(*p);
                             vp->ZoomAuto();
                             vp->Render();
                         }
@@ -151,25 +151,25 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
                 }
             });
 
-            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::ObjectsContext::Prop3DRemoved, [this](uLib::Vtk::Prop3D* p) {
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetRemoved, [this](uLib::Vtk::Puppet* p) {
                 if (p) {
                     auto panes = this->findChildren<ViewportPane*>();
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
-                            vp->RemoveProp3D(*p);
+                            vp->RemovePuppet(*p);
                             vp->Render();
                         }
                     }
                 }
             });
 
-            // Add any prop3ds that were created during m_mainVtkContext's construction to all panes
+            // Add any puppets that were created during m_mainVtkContext's construction to all panes
             auto panes = this->findChildren<ViewportPane*>();
             for (auto* obj : context->GetObjects()) {
-                if (auto* p = m_mainVtkContext->GetProp3D(obj)) {
+                if (auto* p = m_mainVtkContext->GetPuppet(obj)) {
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
-                            vp->AddProp3D(*p);
+                            vp->AddPuppet(*p);
                         }
                     }
                 }

app/gcompose/src/MainPanel.h

@@ -11,7 +11,7 @@ class PropertiesPanel;
 namespace uLib {
     class ObjectsContext;
     namespace Vtk {
-        class ObjectsContext;
+        class vtkObjectsContext;
     }
 }
 
@@ -40,7 +40,7 @@ private:
     ViewportPane* m_firstPane;
     ContextPanel* m_contextPanel;
     uLib::ObjectsContext* m_context;
-    uLib::Vtk::ObjectsContext* m_mainVtkContext;
+    uLib::Vtk::vtkObjectsContext* m_mainVtkContext;
 };
 
 #endif // MAINPANEL_H

app/gcompose/src/PropertyWidgets.cpp

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

app/gcompose/src/QViewportPane.cpp

@@ -88,7 +88,7 @@ void QViewportPane::toggleDisplayPanel() {
 
 void QViewportPane::setObject(uLib::Object* obj) {
     m_displayEditor->setObject(obj, true);
-    // Auto-show panel if it's a prop3d and we want to highlight this feature?
+    // Auto-show panel if it's a puppet and we want to highlight this feature?
     // User asked for "hiding panel", so maybe we don't auto-show.
 }
 
@@ -179,9 +179,9 @@ void QViewportPane::AttemptSplit(Qt::Orientation orientation) {
     if (currentVtk) {
         auto* newVtk = qobject_cast<uLib::Vtk::QViewport*>(newPane->currentViewport());
         if (newVtk) {
-            // Copy prop3ds
+            // Copy puppets
-            for (auto* prop3d : currentVtk->getProp3Ds()) {
+            for (auto* puppet : currentVtk->getPuppets()) {
-                newVtk->AddProp3D(*prop3d);
+                newVtk->AddPuppet(*puppet);
             }
             // Copy camera
             if (currentVtk->GetRenderer() && newVtk->GetRenderer()) {

app/gcompose/src/ViewportPane.cpp

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

conanfile.txt

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

condaenv.yml

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

docs/update_properties.md

@@ -1,21 +1,21 @@
 
 # Properties and the vtk-gui representation
 
-This is the rationale behind the connection between TRS properties and Prop3D Transformation.
+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 Prop3D and Prop3D should propagate the transformation change to the vtk representation object (for instance vtkContainerBox) and the latter eventually propagates the change into the model.
+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 Prop3D or the vtk representation wrapper ( vtkContainerBox for instance is the wrapper od ContainerBox ) should not directly show the transformation of the handlerwidget but it should show the transformation of the model once applied so we are always seeing the actual aspect of the model reflected to the vtk representation and not the other way around.
+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 Prop3D
+## The Puppet
 
-The prop3d is the proxy of the spatial placement of objects in the scene. Prop3Ds should have an internal ContainerBox that is shown in the scene around the content to be able to pick Prop3D from vtkViewport using the handler widget. The HandlerWidget moves the Prop3D ContainerBox (the red Highlight element whe selected) to reflect the handler current transformation, but the transformation is propagated to the derived Prop3D classes like vtkContainerBox. 
+The 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 prop3d internal ContainerBox. The changes of the ContainerBox will be propagated to the derived classes and eventually to the model. 
+The vtkHandlerWidget should handle the transformation of the puppet internal ContainerBox. The changes of the ContainerBox will be propagated to the derived classes and eventually to the model. 
 
 
 

src/Core/Archives.h

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

src/Core/CMakeLists.txt

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

src/Core/Object.cpp

@@ -65,19 +65,10 @@ public:
   std::vector<Slot> slov;
   std::vector<PropertyBase*> m_Properties;
   std::vector<PropertyBase*> m_DynamicProperties;
-  std::vector<PropertyBase*> m_DisplayProperties;
   bool m_SignalsBlocked;
 };
 
 // Implementations of Property methods
-void Object::RegisterDisplayProperty(PropertyBase* prop) {
-    if (prop) d->m_DisplayProperties.push_back(prop);
-}
-
-const std::vector<PropertyBase*>& Object::GetDisplayProperties() const {
-    return d->m_DisplayProperties;
-}
-
 void Object::RegisterProperty(PropertyBase* prop) {
     if (prop) {
         d->m_Properties.push_back(prop);
@@ -113,9 +104,24 @@ void Object::NotifyPropertiesUpdated() {
     for (auto* p : d->m_DynamicProperties) p->Updated();
 }
 
+// In Object.h, the template serialize needs to be updated to call property serialization.
+// However, since Object::serialize is a template in the header, we might need a helper here.
+
+template <class ArchiveT>
+void Object::serialize(ArchiveT &ar, const unsigned int version) {
+    ar & boost::serialization::make_nvp("InstanceName", d->m_InstanceName);
+    for (auto* prop : d->m_Properties) {
+        prop->serialize(ar, version);
+    }
+}
+
 void Object::Updated() { ULIB_SIGNAL_EMIT(Object::Updated); }
 void Object::PropertyUpdated() { ULIB_SIGNAL_EMIT(Object::PropertyUpdated); }
 
+template <class ArchiveT>
+void Object::save_override(ArchiveT &ar, const unsigned int version) {}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

src/Core/Object.h

@@ -92,11 +92,9 @@ public:
 
   ////////////////////////////////////////////////////////////////////////////
   // PROPERTIES //
-  virtual void RegisterProperty(PropertyBase* property);
+  void RegisterProperty(PropertyBase* prop);
-  virtual void RegisterDynamicProperty(PropertyBase* property);
+  void RegisterDynamicProperty(PropertyBase* prop);
-  virtual void RegisterDisplayProperty(PropertyBase* property);
+  const std::vector<PropertyBase*>& GetProperties() const;
-  virtual const std::vector<PropertyBase*>& GetProperties() const;
-  virtual const std::vector<PropertyBase*>& GetDisplayProperties() const;
   PropertyBase* GetProperty(const std::string& name) const;
 
   /** @brief Sends an Updated signal for all properties of this object. useful for real-time UI refresh. */
@@ -126,7 +124,7 @@ public:
   virtual void serialize(Archive::log_archive & ar, const unsigned int version) {}
 
   template <class ArchiveT>
-  void save_override(ArchiveT &ar, const unsigned int version) {}
+  void save_override(ArchiveT &ar, const unsigned int version);
 
   void SaveConfig(std::ostream &os, int version = 0);
   void LoadConfig(std::istream &is, int version = 0);

src/Core/Property.h

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

src/Core/Types.h

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

src/Core/testing/VectorTest.cpp

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

src/HEP/Geant/EmitterPrimary.cpp

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

src/HEP/Geant/EmitterPrimary.hh

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

src/HEP/Geant/Solid.cpp

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

src/Math/Assembly.h

@@ -41,7 +41,7 @@ namespace uLib {
  * transformation that is applied on top of each child's own transform.
  *
  * A bounding box is automatically computed from all contained objects and
- * can be queried or shown/hidden through the VTK prop3d.
+ * can be queried or shown/hidden through the VTK puppet.
  */
 class Assembly : public ObjectsContext, public TRS {
 public:
@@ -81,7 +81,7 @@ public:
 
     /**
      * @brief Controls whether the bounding box wireframe should be shown
-     * in the viewer (used by the VTK prop3d).
+     * in the viewer (used by the VTK puppet).
      */
     void SetShowBoundingBox(bool show);
     bool GetShowBoundingBox() const;

src/Math/Units.h

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

src/Vtk/CMakeLists.txt

@@ -37,8 +37,6 @@ list(APPEND HEADERS ${HEP_GEANT_HEADERS})
 set(LIBRARIES Eigen3::Eigen
               ${ROOT_LIBRARIES}
               ${VTK_LIBRARIES}
-              VTK::ImagingHybrid
-              VTK::ImagingSources
               ${PACKAGE_LIBPREFIX}Math
               ${PACKAGE_LIBPREFIX}Detectors
               ${PACKAGE_LIBPREFIX}Geant)
@@ -58,7 +56,7 @@ set_target_properties(${libname} PROPERTIES
                        AUTOMOC ON
                        AUTOUIC ON
                        AUTORCC ON)
-target_link_libraries(${libname} PUBLIC ${LIBRARIES} Qt6::Widgets)
+target_link_libraries(${libname} ${LIBRARIES} Qt6::Widgets)
 
 install(TARGETS ${libname}
         EXPORT "uLibTargets"

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

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

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

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

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

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

src/Vtk/HEP/Detectors/vtkDetectorChamber.cxx

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

src/Vtk/HEP/Detectors/vtkDetectorChamber.h

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

src/Vtk/HEP/Detectors/vtkMuonEvent.cxx

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

src/Vtk/HEP/Detectors/vtkMuonEvent.h

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

src/Vtk/HEP/Detectors/vtkMuonScatter.cxx

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

src/Vtk/HEP/Detectors/vtkMuonScatter.h

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

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

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

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

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

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

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

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

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

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

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

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

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

src/Vtk/HEP/Geant/vtkBoxSolid.cpp

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

src/Vtk/HEP/Geant/vtkBoxSolid.h

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

src/Vtk/HEP/Geant/vtkEmitterPrimary.cpp

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

src/Vtk/HEP/Geant/vtkEmitterPrimary.h

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

src/Vtk/HEP/Geant/vtkGeantEvent.cpp

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

src/Vtk/HEP/Geant/vtkGeantEvent.h

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

src/Vtk/HEP/Geant/vtkGeantScene.cpp

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

src/Vtk/HEP/Geant/vtkGeantScene.h

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

src/Vtk/HEP/Geant/vtkGeantSolid.cpp

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

src/Vtk/HEP/Geant/vtkGeantSolid.h

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

src/Vtk/HEP/Geant/vtkTessellatedSolid.cpp

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

src/Vtk/HEP/Geant/vtkTessellatedSolid.h

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

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

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

src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.h

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

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.cpp

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

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h

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

src/Vtk/Math/testing/vtkAssemblyTest.cpp

@@ -9,9 +9,9 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-#include "Vtk/Math/vtkAssembly.h"
+#include "Math/Assembly.h"
-#include "Vtk/Math/vtkContainerBox.h"
+#include "Math/ContainerBox.h"
-#include "Vtk/Math/vtkCylinder.h"
+#include "Math/Cylinder.h"
 #include "Vtk/Math/vtkAssembly.h"
 #include "Vtk/vtkObjectsContext.h"
 #include "Vtk/uLibVtkViewer.h"
@@ -50,18 +50,18 @@ int main(int argc, char **argv) {
     // ---- 3. Apply a group transform ----
     assembly.SetPosition(Vector3f(1_m, 1_m, 0));
 
-    // ---- 5. Visualize (create prop3ds to set properties) ----
+    // ---- 5. Visualize (create puppets to set properties) ----
     Vtk::Assembly vtkAsm(&assembly);
 
     Vtk::Viewer viewer;
-    vtkAsm.AddToViewer(viewer); // This triggers prop3d creation via ConnectRenderer which eventually calls Prop3D::GetProp
+    vtkAsm.AddToViewer(viewer); // This triggers puppet creation via ConnectRenderer which eventually calls Puppet::GetProp
     
-    // Explicitly update to ensure prop3ds exist and are added to assemblies
+    // Explicitly update to ensure puppets exist and are added to assemblies
     vtkAsm.Update();
 
-    // Use the child context to find child prop3ds and set colors
+    // Use the child context to find child puppets and set colors
     if (auto* childCtx = vtkAsm.GetChildrenContext()) {
-        auto setProps = [](Vtk::Prop3D* p, float r, float g, float b) {
+        auto setProps = [](Vtk::Puppet* p, float r, float g, float b) {
             if (!p) return;
             vtkPropCollection* props = p->GetProps();
             props->InitTraversal();
@@ -74,12 +74,12 @@ int main(int argc, char **argv) {
             }
         };
 
-        setProps(childCtx->GetProp3D(&box1), 1.0, 0.0, 0.0); // Red
+        setProps(childCtx->GetPuppet(&box1), 1.0, 0.0, 0.0); // Red
-        setProps(childCtx->GetProp3D(&box2), 0.0, 1.0, 0.0); // Green
+        setProps(childCtx->GetPuppet(&box2), 0.0, 1.0, 0.0); // Green
-        setProps(childCtx->GetProp3D(&cyl),  0.0, 0.0, 1.0); // Blue
+        setProps(childCtx->GetPuppet(&cyl),  0.0, 0.0, 1.0); // Blue
     }
 
-    std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
+    std::cout << "Puppets in viewport: " << viewer.getPuppets().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
 
     // ---- 4. Query the bounding box for terminal output ----
     Vector3f bbMin, bbMax;

src/Vtk/Math/testing/vtkContainerBoxTest.cpp

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

src/Vtk/Math/testing/vtkContainerBoxTest2.cpp

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

src/Vtk/Math/testing/vtkQuadMeshTest.cpp

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

src/Vtk/Math/testing/vtkStructuredGridTest.cpp

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

src/Vtk/Math/testing/vtkTriangleMeshTest.cpp

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

src/Vtk/Math/testing/vtkVoxImageInteractiveTest.cpp

@@ -10,7 +10,7 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 #include "Vtk/Math/vtkVoxImage.h"
-#include "Vtk/Math/vtkVoxImage.h"
+#include "Math/VoxImage.h"
 #include "Vtk/uLibVtkViewer.h"
 #include <vtkSmartPointer.h>
 #include <vtkCallbackCommand.h>
@@ -24,7 +24,7 @@
 using namespace uLib;
 
 struct AppState {
-    std::vector<Vtk::VoxImage*> images;
+    std::vector<Vtk::vtkVoxImage*> images;
     Vtk::Viewer* viewer;
 };
 
@@ -35,12 +35,12 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
     std::string key = interactor->GetKeySym();
     if (key == "w") {
         std::cout << "--> Switching all images to Wireframe Box" << std::endl;
-        for (auto* img : state->images) img->SetRepresentation(Vtk::Prop3D::Wireframe);
+        for (auto* img : state->images) img->SetRepresentation(Vtk::Puppet::Wireframe);
         state->viewer->GetRenderWindow()->Render();
     }
     else if (key == "s") {
         std::cout << "--> Switching all images to Surface (Volume Rendering)" << std::endl;
-        for (auto* img : state->images) img->SetRepresentation(Vtk::Prop3D::Surface);
+        for (auto* img : state->images) img->SetRepresentation(Vtk::Puppet::Surface);
         state->viewer->GetRenderWindow()->Render();
     }
     else if (key >= "0" && key <= "5") {
@@ -96,16 +96,16 @@ int main(int argc, char** argv) {
         }
     }
 
-    Vtk::VoxImage vtk_img1(img1);
+    Vtk::vtkVoxImage vtk_img1(img1);
     vtk_img1.setShadingPreset(0);
 
-    Vtk::VoxImage vtk_img2(img2);
+    Vtk::vtkVoxImage vtk_img2(img2);
     vtk_img2.setShadingPreset(1); // Use Composite without MIP for variety
 
     Vtk::Viewer viewer;
     viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
-    viewer.AddProp3D(vtk_img1);
+    viewer.AddPuppet(vtk_img1);
-    viewer.AddProp3D(vtk_img2);
+    viewer.AddPuppet(vtk_img2);
     
     // Setup KeyPress Callback
     AppState state;
@@ -119,7 +119,7 @@ int main(int argc, char** argv) {
     viewer.GetInteractor()->AddObserver(vtkCommand::KeyPressEvent, keyCallback);
 
     std::cout << "=========================================" << std::endl;
-    std::cout << " VoxImage Interactive Viewer Test" << std::endl;
+    std::cout << " vtkVoxImage Interactive Viewer Test" << std::endl;
     std::cout << " [LEFT] Spherical Shell (MIP)" << std::endl;
     std::cout << " [RIGHT] Axes Gradient (Composite)" << std::endl;
     std::cout << "-----------------------------------------" << std::endl;

src/Vtk/Math/testing/vtkVoxImageTest.cpp

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

src/Vtk/Math/vtkAssembly.cpp

@@ -11,7 +11,7 @@
 
 #include "vtkAssembly.h"       // uLib::Vtk::Assembly
 #include "Vtk/vtkObjectsContext.h"
-#include "Vtk/Math/vtkDense.h"
+#include "Math/vtkDense.h"
 
 #include <vtkAssembly.h>       // VTK library ::vtkAssembly
 #include <vtkActor.h>
@@ -75,9 +75,9 @@ void Assembly::InstallPipe() {
 
     m_VtkAsm->AddPart(m_BBoxActor);
 
-    // 3. Build a child-objects context (auto-creates prop3ds for each child)
+    // 3. Build a child-objects context (auto-creates puppets for each child)
     if (m_Content) {
-        m_ChildContext = new ObjectsContext(m_Content);
+        m_ChildContext = new vtkObjectsContext(m_Content);
         // Link the children context's assembly into our group assembly
         if (auto* childProp = vtkProp3D::SafeDownCast(m_ChildContext->GetProp())) {
             m_VtkAsm->AddPart(childProp);
@@ -101,7 +101,7 @@ void Assembly::Update() {
         m_VtkAsm->Modified();
     }
 
-    this->Prop3D::Update();
+    this->Puppet::Update();
     this->UpdateBoundingBox();
     if (m_ChildContext)
         m_ChildContext->Update();
@@ -189,7 +189,7 @@ void Assembly::UpdateBoundingBox() {
 }
 
 // ------------------------------------------------------------------ //
-ObjectsContext *Assembly::GetChildrenContext() const {
+vtkObjectsContext *Assembly::GetChildrenContext() const {
     return m_ChildContext;
 }
 

src/Vtk/Math/vtkAssembly.h

@@ -21,22 +21,22 @@ class vtkAssembly;  // VTK library forward declaration (must be before namespace
 namespace uLib {
 namespace Vtk {
 
-class ObjectsContext; // forward
+class vtkObjectsContext; // forward
 
 /**
- * @brief VTK Prop3D for visualizing uLib::Assembly.
+ * @brief VTK Puppet for visualizing uLib::Assembly.
  *
  * Manages a VTK assembly (vtkAssembly from the VTK library) that groups
- * all child prop3ds and applies the Assembly's AffineTransform. It also
+ * all child puppets and applies the Assembly's AffineTransform. It also
  * renders an optional bounding box wireframe computed from the Assembly's AABB.
  *
  * @note This class is uLib::Vtk::Assembly. It internally uses
  *       the VTK library class vtkAssembly for grouping, but the two
  *       are distinct.
  */
-class Assembly : public Prop3D {
+class Assembly : public Puppet {
 public:
-    uLibTypeMacro(Assembly, Prop3D)
+    uLibTypeMacro(Assembly, Puppet)
 
     Assembly(uLib::Assembly *content);
     virtual ~Assembly();
@@ -51,18 +51,18 @@ public:
     virtual uLib::ObjectsContext* GetChildren() override { return (uLib::ObjectsContext*)m_Content; }
 
     /**
-     * @brief Returns the prop3d managing child objects.
+     * @brief Returns the puppet managing child objects.
      */
 
-    /** @brief Returns the prop3d managing child objects. */
+    /** @brief Returns the puppet managing child objects. */
-    ObjectsContext *GetChildrenContext() const;
+    vtkObjectsContext *GetChildrenContext() const;
 
 private:
     void UpdateBoundingBox();
     void InstallPipe();
 
     uLib::Assembly     *m_Content;
-    ObjectsContext  *m_ChildContext;
+    vtkObjectsContext  *m_ChildContext;
     vtkActor           *m_BBoxActor;
     ::vtkAssembly      *m_VtkAsm; // VTK library assembly — NOT this class
     bool                m_InUpdate;    // re-entrancy guard

src/Vtk/Math/vtkContainerBox.cpp

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

src/Vtk/Math/vtkContainerBox.h

@@ -37,16 +37,14 @@ namespace Vtk {
 
 struct ContainerBoxData;
 
-class ContainerBox : public Prop3D, public Polydata {
+class vtkContainerBox : public Puppet, public Polydata {
-  
+  typedef ContainerBox Content;
-  uLibTypeMacro(ContainerBox, Prop3D, Polydata)
-  typedef uLib::ContainerBox Content;
 
 public:
-  ContainerBox(Content *content);
+  vtkContainerBox(Content *content);
-  ~ContainerBox();
+  ~vtkContainerBox();
 
-  virtual class vtkPolyData *GetPolyData() const override;
+  virtual class vtkPolyData *GetPolyData() const;
 
   /**
    * @brief Updates the VTK representation from the internal state.
@@ -64,9 +62,9 @@ protected:
   virtual void InstallPipe();
 
   struct ContainerBoxData *d;
-  uLib::ContainerBox            *m_Content;
+  Content                 *m_Content;
+  bool                     m_BlockUpdate = false;
   
-  ULIB_DECLARE_PROPERTIES(ContainerBox)
 };
 
 } // namespace Vtk

src/Vtk/Math/vtkCylinder.cpp

@@ -32,23 +32,23 @@
 #include <vtkProperty.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
-#include "Vtk/Math/vtkDense.h"
+#include "Math/vtkDense.h"
 
 namespace uLib {
 namespace Vtk {
 
-Cylinder::Cylinder(Cylinder::Content *content)
+vtkCylinder::vtkCylinder(vtkCylinder::Content *content)
     : m_Content(content), m_Actor(nullptr), m_VtkAsm(nullptr) {
   this->InstallPipe();
-  m_UpdateSignal = Object::connect(m_Content, &uLib::Object::Updated, this, &Cylinder::Update);
+  m_UpdateSignal = Object::connect(m_Content, &uLib::Object::Updated, this, &vtkCylinder::Update);
 }
 
-Cylinder::~Cylinder() {
+vtkCylinder::~vtkCylinder() {
   if (m_Actor) m_Actor->Delete();
   if (m_VtkAsm) m_VtkAsm->Delete();
 }
 
-void Cylinder::Update() {
+void vtkCylinder::Update() {
   if (!m_Content)
     return;
 
@@ -72,8 +72,8 @@ void Cylinder::Update() {
 
           // Apply Axis alignment
           int axis = m_Content->GetAxis();
-          if (axis == 0) alignment->RotateZ(-90);      // Y -> X
+          if (axis == 0) alignment->RotateZ(-90); // Y -> X
-          else if (axis == 1) ;                        // Y -> Y (identity)
+          else if (axis == 1) ;                   // Y -> Y (identity)
           else if (axis == 2) alignment->RotateX(90);  // Y -> Z
       }
 
@@ -82,10 +82,10 @@ void Cylinder::Update() {
 
   // Delegate rest of update (appearance, render, etc)
   ConnectionBlock blocker(m_UpdateSignal);
-  this->Prop3D::Update();
+  this->Puppet::Update();
 }
 
-void Cylinder::SyncFromVtk() {
+void vtkCylinder::SyncFromVtk() {
   if (!m_Content) return;
   
   vtkProp3D* root = this->GetProxyProp();
@@ -93,14 +93,22 @@ void Cylinder::SyncFromVtk() {
 
   // VTK -> Model: Extract new world TRS from proxy
   vtkMatrix4x4* rootMat = root->GetUserMatrix();
+  if (rootMat) {
+      std::cout << "[vtkCylinder::SyncFromVtk] Read Proxy UserMatrix:" << std::endl;
+      rootMat->Print(std::cout);
+  }
+  
   Matrix4f vtkWorld = VtkToMatrix4f(rootMat);
   
   // Directly sync model from the world matrix
   m_Content->FromMatrix(vtkWorld);
+
+  std::cout << "[vtkCylinder::SyncFromVtk] New Model WorldMatrix:" << std::endl << m_Content->GetWorldMatrix() << std::endl;
+
   m_Content->Updated(); 
 }
 
-void Cylinder::InstallPipe() {
+void vtkCylinder::InstallPipe() {
   if (!m_Content)
     return;
 

src/Vtk/Math/vtkCylinder.h

@@ -41,12 +41,12 @@ namespace Vtk {
  * mathematical state of a Cylinder object. It manages the alignment
  * between VTK's Y-centered cylinder and uLib's Z-based coordinate system.
  */
-class Cylinder : public Prop3D {
+class vtkCylinder : public Puppet {
-  typedef uLib::Cylinder Content;
+  typedef Cylinder Content;
 
 public:
-  Cylinder(Content *content);
+  vtkCylinder(Content *content);
-  virtual ~Cylinder();
+  virtual ~vtkCylinder();
 
   /** Synchronizes the VTK actor with the uLib model matrix and vice-versa */
   virtual void Update() override;

src/Vtk/Math/vtkHLineRepresentation.h

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

src/Vtk/Math/vtkQuadMesh.cpp

@@ -42,14 +42,14 @@
 
 #include <vtkMatrix4x4.h>
 #include <vtkNew.h>
-#include "Vtk/Math/vtkDense.h"
+#include "Math/vtkDense.h"
 #include "Vtk/Math/vtkQuadMesh.h"
 #include <iostream>
 
 namespace uLib {
 namespace Vtk {
 
-void QuadMesh::vtk2uLib_update() {
+void vtkQuadMesh::vtk2uLib_update() {
   vtkIdType number_of_points = m_Poly->GetNumberOfPoints();
   vtkIdType number_of_quads = m_Poly->GetNumberOfPolys();
 
@@ -80,7 +80,7 @@ void QuadMesh::vtk2uLib_update() {
   m_Actor->GetMapper()->Update();
 }
 
-void QuadMesh::uLib2vtk_update() {
+void vtkQuadMesh::uLib2vtk_update() {
   vtkIdType number_of_points = m_content.Points().size();
   vtkIdType number_of_quads = m_content.Quads().size();
 
@@ -110,7 +110,7 @@ void QuadMesh::uLib2vtk_update() {
   m_Poly->Modified();
 }
 
-void QuadMesh::contentUpdate() {
+void vtkQuadMesh::contentUpdate() {
   vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
   if (!vmat) {
     vtkNew<vtkMatrix4x4> mat;
@@ -125,10 +125,10 @@ void QuadMesh::contentUpdate() {
 
   m_Poly->Modified();
   m_Actor->GetMapper()->Update();
-  Prop3D::Update();
+  Puppet::Update();
 }
 
-void QuadMesh::Update() {
+void vtkQuadMesh::Update() {
   vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
   if (!vmat) return;
 
@@ -139,7 +139,7 @@ void QuadMesh::Update() {
 
 // -------------------------------------------------------------------------- //
 
-QuadMesh::QuadMesh(QuadMesh::Content &content)
+vtkQuadMesh::vtkQuadMesh(vtkQuadMesh::Content &content)
     : m_content(content), m_Poly(vtkPolyData::New()), m_Actor(vtkActor::New()) {
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
@@ -151,17 +151,17 @@ QuadMesh::QuadMesh(QuadMesh::Content &content)
   m_Actor->SetUserMatrix(vmat);
 
   this->SetProp(m_Actor);
-  Object::connect(&m_content, &Content::Updated, this, &QuadMesh::contentUpdate);
+  Object::connect(&m_content, &Content::Updated, this, &vtkQuadMesh::contentUpdate);
   this->contentUpdate();
 }
 
-QuadMesh::~QuadMesh() {
+vtkQuadMesh::~vtkQuadMesh() {
-  Object::disconnect(&m_content, &Content::Updated, this, &QuadMesh::contentUpdate);
+  Object::disconnect(&m_content, &Content::Updated, this, &vtkQuadMesh::contentUpdate);
   m_Poly->Delete();
   m_Actor->Delete();
 }
 
-void QuadMesh::ReadFromFile(const char *filename) {
+void vtkQuadMesh::ReadFromFile(const char *filename) {
   vtkSmartPointer<vtkPolyDataReader> reader =
       vtkSmartPointer<vtkPolyDataReader>::New();
   reader->SetFileName(filename);
@@ -170,7 +170,7 @@ void QuadMesh::ReadFromFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void QuadMesh::ReadFromXMLFile(const char *filename) {
+void vtkQuadMesh::ReadFromXMLFile(const char *filename) {
   vtkSmartPointer<vtkXMLPolyDataReader> reader =
       vtkSmartPointer<vtkXMLPolyDataReader>::New();
   reader->SetFileName(filename);
@@ -179,7 +179,7 @@ void QuadMesh::ReadFromXMLFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void QuadMesh::ReadFromObjFile(const char *filename) {
+void vtkQuadMesh::ReadFromObjFile(const char *filename) {
   vtkSmartPointer<vtkOBJReader> reader = vtkSmartPointer<vtkOBJReader>::New();
   reader->SetFileName(filename);
   reader->Update();
@@ -187,7 +187,7 @@ void QuadMesh::ReadFromObjFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void QuadMesh::ReadFromStlFile(const char *filename) {
+void vtkQuadMesh::ReadFromStlFile(const char *filename) {
   vtkSmartPointer<vtkSTLReader> reader = vtkSmartPointer<vtkSTLReader>::New();
   reader->SetFileName(filename);
   reader->Update();
@@ -195,7 +195,7 @@ void QuadMesh::ReadFromStlFile(const char *filename) {
   vtk2uLib_update();
 }
 
-vtkPolyData *QuadMesh::GetPolyData() const { return m_Poly; }
+vtkPolyData *vtkQuadMesh::GetPolyData() const { return m_Poly; }
 
 } // namespace Vtk
 } // namespace uLib

src/Vtk/Math/vtkQuadMesh.h

@@ -36,12 +36,12 @@ class vtkActor;
 namespace uLib {
 namespace Vtk {
 
-class QuadMesh : public Prop3D, public Polydata {
+class vtkQuadMesh : public Puppet, public Polydata {
-  typedef uLib::QuadMesh Content;
+  typedef QuadMesh Content;
 
 public:
-  QuadMesh(Content &content);
+  vtkQuadMesh(Content &content);
-  ~QuadMesh();
+  ~vtkQuadMesh();
 
   void ReadFromFile(const char *filename);
 
@@ -61,7 +61,7 @@ private:
   void vtk2uLib_update();
   void uLib2vtk_update();
 
-  uLib::QuadMesh &m_content;
+  QuadMesh &m_content;
   vtkPolyData *m_Poly;
   vtkActor *m_Actor;
 };

src/Vtk/Math/vtkStructuredGrid.cpp

@@ -27,7 +27,7 @@
 #include "config.h"
 #endif
 
-#include "Vtk/Math/vtkStructuredGrid.h"
+#include "Math/StructuredGrid.h"
 #include "Vtk/Math/vtkStructuredGrid.h"
 
 #include "Vtk/Math/vtkDense.h"
@@ -39,19 +39,19 @@ namespace Vtk {
 ////// VTK STRUCTURED GRID /////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-StructuredGrid::StructuredGrid(Content &content)
+vtkStructuredGrid::vtkStructuredGrid(Content &content)
     : m_Content(&content), m_Actor(vtkActor::New()),
       m_Transform(vtkTransform::New()) {
 
   this->InstallPipe();
 }
 
-StructuredGrid::~StructuredGrid() {
+vtkStructuredGrid::~vtkStructuredGrid() {
   m_Actor->Delete();
   m_Transform->Delete();
 }
 
-void StructuredGrid::SetTransform(vtkTransform *t) {
+void vtkStructuredGrid::SetTransform(vtkTransform *t) {
   vtkMatrix4x4 *vmat = t->GetMatrix();
   Matrix4f mat = VtkToMatrix4f(vmat);
   m_Content->SetMatrix(mat);
@@ -64,7 +64,7 @@ void StructuredGrid::SetTransform(vtkTransform *t) {
   this->Update();
 }
 
-void StructuredGrid::Update() {
+void vtkStructuredGrid::Update() {
   if (!m_Content) return;
 
   vtkProp3D* actor = vtkProp3D::SafeDownCast(this->GetProp());
@@ -86,7 +86,7 @@ void StructuredGrid::Update() {
   m_Content->Updated(); // Notify others (like raytracer)
 }
 
-void StructuredGrid::InstallPipe() {
+void vtkStructuredGrid::InstallPipe() {
   vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
  
   Vector3i dims = m_Content->GetDims();

src/Vtk/Math/vtkStructuredGrid.h

@@ -39,7 +39,7 @@
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 
-#include "Vtk/Math/vtkDense.h"
+#include "Math/Dense.h"
 
 #include "Math/StructuredGrid.h"
 #include "Vtk/uLibVtkInterface.h"
@@ -47,12 +47,12 @@
 namespace uLib {
 namespace Vtk {
 
-class StructuredGrid : public Prop3D {
+class vtkStructuredGrid : public Puppet {
-  typedef uLib::StructuredGrid Content;
+  typedef StructuredGrid Content;
 
 public:
-  StructuredGrid(Content &content);
+  vtkStructuredGrid(Content &content);
-  ~StructuredGrid();
+  ~vtkStructuredGrid();
 
   void SetTransform(class vtkTransform *t);
 
@@ -62,7 +62,7 @@ private:
   void InstallPipe();
 
   vtkActor *m_Actor;
-  uLib::StructuredGrid *m_Content;
+  StructuredGrid *m_Content;
   vtkTransform *m_Transform;
 };
 

src/Vtk/Math/vtkTriangleMesh.cpp

@@ -42,14 +42,14 @@
 
 #include <vtkMatrix4x4.h>
 #include <vtkNew.h>
-#include "Vtk/Math/vtkDense.h"
+#include "Math/vtkDense.h"
 #include "Vtk/Math/vtkTriangleMesh.h"
 #include <iostream>
 
 namespace uLib {
 namespace Vtk {
 
-void TriangleMesh::vtk2uLib_update() {
+void vtkTriangleMesh::vtk2uLib_update() {
   vtkIdType number_of_points = m_Poly->GetNumberOfPoints();
   vtkIdType number_of_triangles = m_Poly->GetNumberOfPolys();
 
@@ -77,7 +77,7 @@ void TriangleMesh::vtk2uLib_update() {
   m_Actor->GetMapper()->Update();
 }
 
-void TriangleMesh::uLib2vtk_update() {
+void vtkTriangleMesh::uLib2vtk_update() {
   vtkIdType number_of_points = m_content.Points().size();
   vtkIdType number_of_triangles = m_content.Triangles().size();
 
@@ -105,7 +105,7 @@ void TriangleMesh::uLib2vtk_update() {
   m_Poly->Modified();
 }
 
-void TriangleMesh::contentUpdate() {
+void vtkTriangleMesh::contentUpdate() {
   vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
   if (!vmat) {
     vtkNew<vtkMatrix4x4> mat;
@@ -120,10 +120,10 @@ void TriangleMesh::contentUpdate() {
 
   m_Poly->Modified();
   m_Actor->GetMapper()->Update();
-  Prop3D::Update();
+  Puppet::Update();
 }
 
-void TriangleMesh::Update() {
+void vtkTriangleMesh::Update() {
   vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
   if (!vmat) return;
 
@@ -134,7 +134,7 @@ void TriangleMesh::Update() {
 
 // -------------------------------------------------------------------------- //
 
-TriangleMesh::TriangleMesh(TriangleMesh::Content &content)
+vtkTriangleMesh::vtkTriangleMesh(vtkTriangleMesh::Content &content)
     : m_content(content), m_Poly(vtkPolyData::New()), m_Actor(vtkActor::New()) {
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
@@ -146,17 +146,17 @@ TriangleMesh::TriangleMesh(TriangleMesh::Content &content)
   m_Actor->SetUserMatrix(vmat);
 
   this->SetProp(m_Actor);
-  Object::connect(&m_content, &Content::Updated, this, &TriangleMesh::contentUpdate);
+  Object::connect(&m_content, &Content::Updated, this, &vtkTriangleMesh::contentUpdate);
   this->contentUpdate();
 }
 
-TriangleMesh::~TriangleMesh() {
+vtkTriangleMesh::~vtkTriangleMesh() {
-  Object::disconnect(&m_content, &Content::Updated, this, &TriangleMesh::contentUpdate);
+  Object::disconnect(&m_content, &Content::Updated, this, &vtkTriangleMesh::contentUpdate);
   m_Poly->Delete();
   m_Actor->Delete();
 }
 
-void TriangleMesh::ReadFromFile(const char *filename) {
+void vtkTriangleMesh::ReadFromFile(const char *filename) {
   vtkSmartPointer<vtkPolyDataReader> reader =
       vtkSmartPointer<vtkPolyDataReader>::New();
   reader->SetFileName(filename);
@@ -165,7 +165,7 @@ void TriangleMesh::ReadFromFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void TriangleMesh::ReadFromXMLFile(const char *filename) {
+void vtkTriangleMesh::ReadFromXMLFile(const char *filename) {
   vtkSmartPointer<vtkXMLPolyDataReader> reader =
       vtkSmartPointer<vtkXMLPolyDataReader>::New();
   reader->SetFileName(filename);
@@ -174,7 +174,7 @@ void TriangleMesh::ReadFromXMLFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void TriangleMesh::ReadFromObjFile(const char *filename) {
+void vtkTriangleMesh::ReadFromObjFile(const char *filename) {
   vtkSmartPointer<vtkOBJReader> reader = vtkSmartPointer<vtkOBJReader>::New();
   reader->SetFileName(filename);
   reader->Update();
@@ -182,7 +182,7 @@ void TriangleMesh::ReadFromObjFile(const char *filename) {
   vtk2uLib_update();
 }
 
-void TriangleMesh::ReadFromStlFile(const char *filename) {
+void vtkTriangleMesh::ReadFromStlFile(const char *filename) {
   vtkSmartPointer<vtkSTLReader> reader = vtkSmartPointer<vtkSTLReader>::New();
   reader->SetFileName(filename);
   reader->Update();
@@ -190,7 +190,7 @@ void TriangleMesh::ReadFromStlFile(const char *filename) {
   vtk2uLib_update();
 }
 
-vtkPolyData *TriangleMesh::GetPolyData() const { return m_Poly; }
+vtkPolyData *vtkTriangleMesh::GetPolyData() const { return m_Poly; }
 
 } // namespace Vtk
 } // namespace uLib

src/Vtk/Math/vtkTriangleMesh.h

@@ -36,12 +36,12 @@ class vtkActor;
 namespace uLib {
 namespace Vtk {
 
-class TriangleMesh : public Prop3D, public Polydata {
+class vtkTriangleMesh : public Puppet, public Polydata {
-  typedef uLib::TriangleMesh Content;
+  typedef TriangleMesh Content;
 
 public:
-  TriangleMesh(Content &content);
+  vtkTriangleMesh(Content &content);
-  ~TriangleMesh();
+  ~vtkTriangleMesh();
 
   void ReadFromFile(const char *filename);
 
@@ -61,7 +61,7 @@ private:
   void vtk2uLib_update();
   void uLib2vtk_update();
 
-  uLib::TriangleMesh &m_content;
+  TriangleMesh &m_content;
   vtkPolyData *m_Poly;
   vtkActor *m_Actor;
 };

src/Vtk/Math/vtkVoxImage.cpp

@@ -60,7 +60,7 @@ VTK_MODULE_INIT(vtkInteractionStyle);
 namespace uLib {
 namespace Vtk {
 
-void VoxImage::UpdateFromContent() {
+void vtkVoxImage::GetContent() {
   Vector3i ev_dims = m_Content.GetDims();
   m_Image->SetDimensions(ev_dims.data());
 
@@ -91,7 +91,7 @@ void VoxImage::UpdateFromContent() {
   }
 }
 
-void VoxImage::UpdateToContent() {
+void vtkVoxImage::SetContent() {
   int *ext = m_Image->GetExtent();
   int dims[3] = {ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, ext[5] - ext[4] + 1};
   m_Content.SetDims(Vector3i(dims[0], dims[1], dims[2]));
@@ -124,7 +124,7 @@ void VoxImage::UpdateToContent() {
 ////////////////////////////////////////////////////////////////////////////////
 // VTK VOXIMAGE
 
-VoxImage::VoxImage(Content &content)
+vtkVoxImage::vtkVoxImage(Content &content)
     : m_Content(content), m_Actor(vtkVolume::New()),
       m_Asm(vtkAssembly::New()),
       m_Image(vtkImageData::New()), m_Outline(vtkCubeSource::New()),
@@ -134,15 +134,15 @@ VoxImage::VoxImage(Content &content)
   // Transfer functions
   m_ColorFun = vtkColorTransferFunction::New();
   m_OpacityFun = vtkPiecewiseFunction::New();
-  m_UpdateConnection = Object::connect(&m_Content, &uLib::Object::Updated, this, &VoxImage::Update);
+  m_UpdateConnection = Object::connect(&m_Content, &uLib::Object::Updated, this, &vtkVoxImage::Update);
   
-  UpdateFromContent();
+  GetContent();
   InstallPipe();
   RescaleShaderRange();
   ULIB_ACTIVATE_DISPLAY_PROPERTIES;
 }
 
-VoxImage::~VoxImage() {
+vtkVoxImage::~vtkVoxImage() {
   m_Image->Delete();
   m_Actor->Delete();
   m_Asm->Delete();
@@ -152,16 +152,16 @@ VoxImage::~VoxImage() {
   m_OpacityFun->Delete();
 }
 
-vtkImageData *VoxImage::GetImageData() {
+vtkImageData *vtkVoxImage::GetImageData() {
-  UpdateFromContent();
+  GetContent();
   return m_Image;
 }
 
-void VoxImage::SaveToXMLFile(const char *fname) {
+void vtkVoxImage::SaveToXMLFile(const char *fname) {
   vtkSmartPointer<vtkXMLImageDataWriter> writer =
       vtkSmartPointer<vtkXMLImageDataWriter>::New();
   writer->SetFileName(fname);
-  UpdateFromContent();
+  GetContent();
   vtkSmartPointer<vtkImageShiftScale> vtkscale =
       vtkSmartPointer<vtkImageShiftScale>::New();
 
@@ -177,7 +177,7 @@ void VoxImage::SaveToXMLFile(const char *fname) {
   writer->Write();
 }
 
-void VoxImage::ReadFromVKTFile(const char *fname) {
+void vtkVoxImage::ReadFromVKTFile(const char *fname) {
   vtkSmartPointer<vtkGenericDataObjectReader> reader =
       vtkSmartPointer<vtkGenericDataObjectReader>::New();
   reader->SetFileName(fname);
@@ -190,7 +190,7 @@ void VoxImage::ReadFromVKTFile(const char *fname) {
     vtkscale->Update();
 
     m_Image->DeepCopy(vtkscale->GetOutput());
-    UpdateToContent();
+    SetContent();
     RescaleShaderRange();
   } else {
     std::cerr << "Error: file does not contain structured points\n";
@@ -198,7 +198,7 @@ void VoxImage::ReadFromVKTFile(const char *fname) {
   m_Actor->Update();
 }
 
-void VoxImage::ReadFromXMLFile(const char *fname) {
+void vtkVoxImage::ReadFromXMLFile(const char *fname) {
   vtkSmartPointer<vtkXMLImageDataReader> reader =
       vtkSmartPointer<vtkXMLImageDataReader>::New();
   reader->SetFileName(fname);
@@ -210,11 +210,11 @@ void VoxImage::ReadFromXMLFile(const char *fname) {
   vtkscale->Update();
 
   m_Image->DeepCopy(vtkscale->GetOutput());
-  UpdateToContent();
+  SetContent();
   RescaleShaderRange();
 }
 
-void VoxImage::setShadingPreset(int blendType) {
+void vtkVoxImage::setShadingPreset(int blendType) {
   m_ShadingPreset = blendType;
   vtkSmartVolumeMapper *mapper = (vtkSmartVolumeMapper *)m_Actor->GetMapper();
   if (!mapper) return;
@@ -270,7 +270,7 @@ void VoxImage::setShadingPreset(int blendType) {
   }
 }
 
-void VoxImage::RescaleShaderRange() {
+void vtkVoxImage::RescaleShaderRange() {
   double range[2];
   m_Image->GetScalarRange(range);
   m_Level = (range[0] + range[1]) / 2.0;
@@ -280,8 +280,8 @@ void VoxImage::RescaleShaderRange() {
   setShadingPreset(m_ShadingPreset);
 }
 
-void VoxImage::SetRepresentation(Representation mode) {
+void vtkVoxImage::SetRepresentation(Representation mode) {
-  Prop3D::SetRepresentation(mode); // Ensure base class data state is updated
+  Puppet::SetRepresentation(mode); // Ensure base class data state is updated
 
   if (mode == Wireframe) {
     m_Actor->SetVisibility(0);
@@ -292,14 +292,14 @@ void VoxImage::SetRepresentation(Representation mode) {
     m_OutlineActor->SetVisibility(1);
     m_OutlineActor->GetProperty()->SetRepresentationToWireframe();
   } else {
-    // Other representations (Points, Surface, etc) are handled by basic Prop3D
+    // Other representations (Points, Surface, etc) are handled by basic Puppet
     // behavior which affects the m_Asm parts.
   }
 }
 
-void VoxImage::serialize_display(uLib::Archive::display_properties_archive & ar, const unsigned int version) {
+void vtkVoxImage::serialize_display(uLib::Archive::display_properties_archive & ar, const unsigned int version) {
     // Call base class to show Transform and Appearance properties
-    // Prop3D::serialize_display(ar, version);
+    // Puppet::serialize_display(ar, version);
     
     // Use the member variables for volume rendering parameters
     ar & boost::serialization::make_hrp("Window", m_Window);
@@ -308,7 +308,7 @@ void VoxImage::serialize_display(uLib::Archive::display_properties_archive & ar,
       {"MIP", "Composite", "Composite Shaded", "MIP Bone", "MIP Hot", "Additive"});
 }
 
-void VoxImage::SyncFromVtk() {
+void vtkVoxImage::SyncFromVtk() {
   if (auto *root = this->GetProxyProp()) {
     vtkMatrix4x4 *rootMat = root->GetUserMatrix();
     if (rootMat) {
@@ -320,13 +320,13 @@ void VoxImage::SyncFromVtk() {
   }
 }
 
-void VoxImage::Update() {
+void vtkVoxImage::Update() {
   if (auto *root = vtkProp3D::SafeDownCast(this->GetProp())) {
     vtkNew<vtkMatrix4x4> m;
     Matrix4fToVtk(m_Content.GetMatrix(), m); // * m_Content.GetLocalMatrix(), m);
     root->SetUserMatrix(m);
     root->Modified();
-    // std::cout << "[VoxImage::Update] Set Proxy UserMatrix:" << std::endl;
+    // std::cout << "[vtkVoxImage::Update] Set Proxy UserMatrix:" << std::endl;
     // std::cout << m_Content.GetMatrix() << std::endl;
   }
   setShadingPreset(m_ShadingPreset);
@@ -335,11 +335,11 @@ void VoxImage::Update() {
   m_Outline->Update();
 
   ConnectionBlock blocker(m_UpdateConnection);
-  this->Prop3D::Update();
+  this->Puppet::Update();
 }
 
 
-void VoxImage::InstallPipe() {
+void vtkVoxImage::InstallPipe() {
   vtkSmartPointer<vtkSmartVolumeMapper> mapper =
       vtkSmartPointer<vtkSmartVolumeMapper>::New();
 #if VTK_MAJOR_VERSION <= 5

src/Vtk/Math/vtkVoxImage.h

@@ -45,18 +45,17 @@ class vtkPiecewiseFunction;
 namespace uLib {
 namespace Vtk {
 
-class VoxImage : public Prop3D {
+class vtkVoxImage : public Puppet {
 public:
   typedef Abstract::VoxImage Content;
 
-  VoxImage(Content &content);
+  vtkVoxImage(Content &content);
 
-  ~VoxImage();
+  ~vtkVoxImage();
 
-  void UpdateFromContent();
+  void GetContent();
 
-  void UpdateToContent();
+  void SetContent();
-  uLib::Object* GetContent() const override { return (uLib::Object*)&m_Content; }
 
   vtkProp3D *GetProp() override { return m_Asm; }
 
@@ -90,7 +89,7 @@ private:
   vtkXMLImageDataReader *m_Reader;
   vtkXMLImageDataWriter *m_Writer;
 
-  VoxImage::Content &m_Content;
+  vtkVoxImage::Content &m_Content;
 
   float m_Window;
   float m_Level;

src/Vtk/testing/CMakeLists.txt

@@ -2,8 +2,8 @@
 set(TESTS
         vtkViewerTest
         vtkHandlerWidget
-        Prop3DPropertyTest
+        PuppetPropertyTest
-        Prop3DParentingTest
+        PuppetParentingTest
         vtkQViewportTest
         # vtkVoxImageTest
 #	vtkTriangleMeshTest

src/Vtk/testing/PuppetParentingTest.cpp

@@ -26,14 +26,14 @@
 using namespace uLib;
 
 int main() {
-    BEGIN_TESTING(Prop3D Parenting Test);
+    BEGIN_TESTING(Puppet Parenting Test);
 
     ObjectsContext globalContext;
     Vtk::Viewer viewer;
     
     // Create the display context, linked to the model context.
-    // It will automatically create visual prop3ds for each model object.
+    // It will automatically create visual puppets for each model object.
-    Vtk::ObjectsContext viewerContext(&globalContext);
+    Vtk::vtkObjectsContext viewerContext(&globalContext);
     viewerContext.ConnectRenderer(viewer.GetRenderer());
 
     // 1. Create a model Assembly
@@ -41,12 +41,12 @@ int main() {
     assembly->SetInstanceName("ParentAssembly");
     globalContext.AddObject(assembly);
 
-    // Verify assembly prop3d exists in the viewer context
+    // Verify assembly puppet exists in the viewer context
-    Vtk::Prop3D* assemblyProp3D = viewerContext.GetProp3D(assembly);
+    Vtk::Puppet* assemblyPuppet = viewerContext.GetPuppet(assembly);
-    ASSERT_NOT_NULL(assemblyProp3D);
+    ASSERT_NOT_NULL(assemblyPuppet);
     
     // cast to Vtk::Assembly to access child context
-    auto* vtkAss = dynamic_cast<Vtk::Assembly*>(assemblyProp3D);
+    auto* vtkAss = dynamic_cast<Vtk::Assembly*>(assemblyPuppet);
     ASSERT_NOT_NULL(vtkAss);
 
     // 2. Create a child Box and add it to the Assembly
@@ -55,25 +55,25 @@ int main() {
     box1->SetPosition(Vector3f(20, 0, 0));
     assembly->AddObject(box1);
 
-    // Verify child prop3d was created in the assembly's child context
+    // Verify child puppet was created in the assembly's child context
-    Vtk::ObjectsContext* childVtkCtx = vtkAss->GetChildrenContext();
+    Vtk::vtkObjectsContext* childVtkCtx = vtkAss->GetChildrenContext();
     ASSERT_NOT_NULL(childVtkCtx);
     
-    Vtk::Prop3D* box1Prop3D = childVtkCtx->GetProp3D(box1);
+    Vtk::Puppet* box1Puppet = childVtkCtx->GetPuppet(box1);
-    ASSERT_NOT_NULL(box1Prop3D);
+    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(box1Prop3D->GetProp());
+    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 prop3d ApplyTransform sets the prop orientation and position.
+    // The puppet ApplyTransform sets the prop orientation and position.
     
     std::cout << "Checking transformation chain..." << std::endl;
     // std::cout << *boxMatrix << std::endl;
@@ -93,8 +93,8 @@ int main() {
     box2->SetPosition(Vector3f(-20, 0, 0));
     assembly->AddObject(box2);
     
-    Vtk::Prop3D* box2Prop3D = childVtkCtx->GetProp3D(box2);
+    Vtk::Puppet* box2Puppet = childVtkCtx->GetPuppet(box2);
-    ASSERT_NOT_NULL(box2Prop3D);
+    ASSERT_NOT_NULL(box2Puppet);
 
     // Render if not in batch environment
     if (!std::getenv("CTEST_PROJECT_NAME")) {

src/Vtk/testing/PuppetPropertyTest.cpp

@@ -19,13 +19,13 @@ using namespace uLib;
 using namespace Vtk;
 
 int main() {
-    BEGIN_TESTING(Prop3D Property Registration Test);
+    BEGIN_TESTING(Puppet Property Registration Test);
 
-    std::cout << "Creating Prop3D object..." << std::endl;
+    std::cout << "Creating Puppet object..." << std::endl;
-    Prop3D p;
+    Puppet p;
     
-    // At this point, the Prop3D constructor has called ULIB_ACTIVATE_PROPERTIES.
+    // At this point, the Puppet constructor has called ULIB_ACTIVATE_PROPERTIES.
-    // This should have discovered the members used in Prop3D::serialize() 
+    // This should have discovered the members used in Puppet::serialize() 
     // and registered them as uLib properties.
     
     const auto& props = p.GetProperties();
@@ -62,7 +62,7 @@ int main() {
     *colorRProp = 0.9;
     assert(colorRProp->Get() == 0.9);
 
-    std::cout << "All Prop3D Property Registration Tests PASSED!" << std::endl;
+    std::cout << "All Puppet Property Registration Tests PASSED!" << std::endl;
 
     END_TESTING;
 }

src/Vtk/testing/vtkHandlerWidget.cpp

@@ -23,7 +23,7 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-#include "Vtk/Math/vtkContainerBox.h"
+#include "Math/ContainerBox.h"
 #include "Vtk/uLibVtkViewer.h"
 #include "Vtk/Math/vtkContainerBox.h"
 #include "Vtk/vtkHandlerWidget.h"
@@ -39,7 +39,7 @@
 using namespace uLib;
 
 int main() {
-  BEGIN_TESTING(HandlerWidget with ContainerBox);
+  BEGIN_TESTING(vtkHandlerWidget with ContainerBox);
 
   // 1. Create a ContainerBox (Math object)
   ContainerBox box;
@@ -49,20 +49,20 @@ int main() {
   // 3. Setup the Viewer
   Vtk::Viewer viewer;
 
-  // 2. Wrap it in a Vtk::ContainerBox (Vtk Prop3D)
+  // 2. Wrap it in a Vtk::vtkContainerBox (Vtk Puppet)
-  Vtk::ContainerBox v_box(&box);
+  Vtk::vtkContainerBox v_box(&box);
-  v_box.SetRepresentation(Vtk::Prop3D::Surface);
+  v_box.SetRepresentation(Vtk::Puppet::Surface);
   v_box.SetOpacity(0.5);
 
-  viewer.AddProp3D(v_box);
+  viewer.AddPuppet(v_box);
 
-  // 4. Create and setup the HandlerWidget
+  // 4. Create and setup the vtkHandlerWidget
-  vtkSmartPointer<Vtk::HandlerWidget> handler =
+  vtkSmartPointer<Vtk::vtkHandlerWidget> handler =
-      vtkSmartPointer<Vtk::HandlerWidget>::New();
+      vtkSmartPointer<Vtk::vtkHandlerWidget>::New();
 
   handler->SetInteractor(viewer.GetInteractor());
 
-  // Get the prop from the prop3d and cast it to vtkProp3D
+  // Get the prop from the puppet and cast it to vtkProp3D
   vtkProp *v_prop = v_box.GetProp();
   vtkProp3D *prop = vtkProp3D::SafeDownCast(v_prop);
   if (!prop) {
@@ -83,20 +83,20 @@ int main() {
   auto key_callback = vtkSmartPointer<vtkCallbackCommand>::New();
   key_callback->SetCallback([](vtkObject *caller, unsigned long, void *clientData, void *) {
       auto interactor = static_cast<vtkRenderWindowInteractor *>(caller);
-      auto h = static_cast<Vtk::HandlerWidget *>(clientData);
+      auto h = static_cast<Vtk::vtkHandlerWidget *>(clientData);
       std::string key = interactor->GetKeySym();
       if (key == "g") {
           std::cout << "Switching to GLOBAL frame" << std::endl;
-          h->SetReferenceFrame(Vtk::HandlerWidget::GLOBAL);
+          h->SetReferenceFrame(Vtk::vtkHandlerWidget::GLOBAL);
       } else if (key == "l") {
           std::cout << "Switching to LOCAL frame" << std::endl;
-          h->SetReferenceFrame(Vtk::HandlerWidget::LOCAL);
+          h->SetReferenceFrame(Vtk::vtkHandlerWidget::LOCAL);
       } else if (key == "c") {
           std::cout << "Switching to CENTER frame" << std::endl;
-          h->SetReferenceFrame(Vtk::HandlerWidget::CENTER);
+          h->SetReferenceFrame(Vtk::vtkHandlerWidget::CENTER);
       } else if (key == "k") {
           std::cout << "Switching to CENTER_LOCAL frame" << std::endl;
-          h->SetReferenceFrame(Vtk::HandlerWidget::CENTER_LOCAL);
+          h->SetReferenceFrame(Vtk::vtkHandlerWidget::CENTER_LOCAL);
       }
   });
   key_callback->SetClientData(handler.GetPointer());

src/Vtk/uLibVtkInterface.cxx

@@ -63,7 +63,7 @@
 
 #include "uLibVtkInterface.h"
 #include "vtkHandlerWidget.h"
-#include "Vtk/Math/vtkDense.h"
+#include "Math/Dense.h"
 #include "Vtk/Math/vtkDense.h"
 #include "Core/Property.h"
 #include "Math/Transform.h"
@@ -80,15 +80,15 @@ namespace Vtk {
 
 // PIMPL -------------------------------------------------------------------- //
 
-class Prop3DData {
+class PuppetData {
 public:
-    Prop3DData(Prop3D* owner) :
+    PuppetData(Puppet* owner) :
-        m_Prop3D(owner),
+        m_Puppet(owner),
         m_Renderers(vtkSmartPointer<vtkRendererCollection>::New()),
         m_Prop(nullptr),
         m_ShowBoundingBox(false),
         m_ShowScaleMeasures(false),
-        m_Representation(Prop3D::Surface),
+        m_Representation(Puppet::Surface),
         m_Opacity(1.0),
         m_Selectable(true),
         m_Selected(false),
@@ -98,12 +98,11 @@ public:
         m_Color = Vector3d(-1, -1, -1);
     }
 
-    ~Prop3DData() {
+    ~PuppetData() {
         // No manual Delete needed for smart pointers
-
     }
 
-    Prop3D *m_Prop3D;
+    Puppet *m_Puppet;
     // members //
     vtkSmartPointer<vtkRendererCollection> m_Renderers;
     vtkSmartPointer<vtkProp3D>             m_Prop;
@@ -113,10 +112,9 @@ public:
     vtkSmartPointer<vtkCubeAxesActor>      m_CubeAxesActor;
     vtkSmartPointer<vtkActor>              m_HighlightActor;
 
-    // Display properties
     bool m_ShowBoundingBox;
     bool m_ShowScaleMeasures;
-    int  m_Representation; // 0: Points, 1: Wireframe, 2: Surface, 3: SurfaceWithEdges, 4: Volume, 5: Outline, 6: Slice
+    int m_Representation;
     Vector3d m_Color;
     double m_Opacity;
 
@@ -136,11 +134,11 @@ public:
 
         vtkActor *actor = vtkActor::SafeDownCast(p);
         if (actor) {
-            if (m_Representation != -1 && m_Representation != Prop3D::Volume) {
+            if (m_Representation != -1 && m_Representation != Puppet::Volume) {
-                if (m_Representation == Prop3D::SurfaceWithEdges) {
+                if (m_Representation == Puppet::SurfaceWithEdges) {
                     actor->GetProperty()->SetRepresentation(VTK_SURFACE);
                     actor->GetProperty()->SetEdgeVisibility(1);
-                } else if (m_Representation != Prop3D::Outline && m_Representation != Prop3D::Slice) {
+                } else if (m_Representation != Puppet::Outline && m_Representation != Puppet::Slice) {
                     actor->GetProperty()->SetRepresentation(m_Representation);
                     actor->GetProperty()->SetEdgeVisibility(0);
                 }
@@ -181,10 +179,11 @@ public:
 
     void UpdateHighlight() {
         if (m_Selected) {
+            // Find first polydata in assembly to highlight
             vtkPolyData* polydata = nullptr;
             if (vtkActor *actor = vtkActor::SafeDownCast(m_Prop)) {
                 if (actor->GetMapper()) {
-                    polydata = vtkPolyData::SafeDownCast(actor->GetMapper()->GetInput());
+                    polydata = vtkPolyData::SafeDownCast(actor->GetMapper()->GetDataSetInput());
                 }
             } else if (vtkAssembly *asm_p = vtkAssembly::SafeDownCast(m_Prop)) {
                 vtkPropCollection *parts = asm_p->GetParts();
@@ -193,7 +192,7 @@ public:
                     for (int i = 0; i < parts->GetNumberOfItems(); ++i) {
                         vtkActor *a = vtkActor::SafeDownCast(parts->GetNextProp());
                         if (a && a->GetMapper()) {
-                            polydata = vtkPolyData::SafeDownCast(a->GetMapper()->GetInput());
+                            polydata = vtkPolyData::SafeDownCast(a->GetMapper()->GetDataSetInput());
                             if (polydata) break;
                         }
                     }
@@ -248,8 +247,8 @@ public:
             }
 
             // Update highlight matrix from the model world matrix
-            if (m_Prop3D) {
+            if (m_Puppet) {
-                if (auto* content = m_Prop3D->GetContent()) {
+                if (auto* content = m_Puppet->GetContent()) {
                     if (auto* tr = dynamic_cast<uLib::TRS*>(content)) {
                         vtkNew<vtkMatrix4x4> vwm;
                         Matrix4fToVtk(tr->GetWorldMatrix(), vwm);
@@ -288,24 +287,24 @@ public:
 
 
 
-Prop3D::Prop3D() : Object(), pd(new Prop3DData(this)) { 
+Puppet::Puppet() : Object(), pd(new PuppetData(this)) { 
     ULIB_ACTIVATE_DISPLAY_PROPERTIES;
     for (auto* p : this->GetDisplayProperties()) {
-        uLib::Object::connect(p, &uLib::PropertyBase::Updated, this, &Prop3D::Update);
+        uLib::Object::connect(p, &uLib::PropertyBase::Updated, this, &Puppet::Update);
     }
 }
 
-Prop3D::~Prop3D()
+Puppet::~Puppet()
 {
     delete pd;
 }
 
-vtkProp *Prop3D::GetProp()
+vtkProp *Puppet::GetProp()
 {
     return pd->m_Prop;
 }
 
-vtkProp3D *Prop3D::GetProxyProp()
+vtkProp3D *Puppet::GetProxyProp()
 {
     // The handler should manipulate the highlight actor if it exists
     if (pd->m_HighlightActor) {
@@ -314,7 +313,7 @@ vtkProp3D *Prop3D::GetProxyProp()
     return vtkProp3D::SafeDownCast(this->GetProp());
 }
 
-void Prop3D::SetProp(vtkProp *prop)
+void Puppet::SetProp(vtkProp *prop)
 {
     if(prop) {
         prop->SetPickable(pd->m_Selectable);
@@ -339,23 +338,23 @@ void Prop3D::SetProp(vtkProp *prop)
     }
 }
 
-void Prop3D::RemoveProp(vtkProp *prop)
+void Puppet::RemoveProp(vtkProp *prop)
 {
     // TODO
 }
 
-void Prop3D::ApplyAppearance(vtkProp* prop)
+void Puppet::ApplyAppearance(vtkProp* prop)
 {
     pd->ApplyAppearance(prop);
 }
 
-void Prop3D::ApplyTransform(vtkProp3D* p3d)
+void Puppet::ApplyTransform(vtkProp3D* p3d)
 {
     pd->ApplyTransform(p3d);
 }
 
 
-vtkPropCollection *Prop3D::GetParts()
+vtkPropCollection *Puppet::GetParts()
 {
     if (auto* asm_p = vtkAssembly::SafeDownCast(pd->m_Prop)) {
         return asm_p->GetParts();
@@ -363,7 +362,7 @@ vtkPropCollection *Prop3D::GetParts()
     return nullptr;
 }
 
-vtkPropCollection *Prop3D::GetProps()
+vtkPropCollection *Puppet::GetProps()
 {
     if (auto* asm_p = vtkAssembly::SafeDownCast(pd->m_Prop)) {
         return asm_p->GetParts();
@@ -371,7 +370,7 @@ vtkPropCollection *Prop3D::GetProps()
     return nullptr;
 }
 
-void Prop3D::ConnectRenderer(vtkRenderer *renderer)
+void Puppet::ConnectRenderer(vtkRenderer *renderer)
 {
     if(renderer) {
         this->GetRenderers()->AddItem(renderer);
@@ -391,7 +390,7 @@ void Prop3D::ConnectRenderer(vtkRenderer *renderer)
     }
 }
 
-void Prop3D::DisconnectRenderer(vtkRenderer *renderer)
+void Puppet::DisconnectRenderer(vtkRenderer *renderer)
 {
     if(renderer) {
         if(vtkProp* prop = this->GetProp())
@@ -404,22 +403,22 @@ void Prop3D::DisconnectRenderer(vtkRenderer *renderer)
     }
 }
 
-void Prop3D::AddToViewer(Viewport &viewer)
+void Puppet::AddToViewer(Viewport &viewer)
 {
-    viewer.AddProp3D(*this);
+    viewer.AddPuppet(*this);
 }
 
-void Prop3D::RemoveFromViewer(Viewport &viewer)
+void Puppet::RemoveFromViewer(Viewport &viewer)
 {
-    viewer.RemoveProp3D(*this);
+    viewer.RemovePuppet(*this);
 }
 
-vtkRendererCollection *Prop3D::GetRenderers() const
+vtkRendererCollection *Puppet::GetRenderers() const
 {
     return pd->m_Renderers;
 }
 
-void Prop3D::PrintSelf(std::ostream &o) const
+void Puppet::PrintSelf(std::ostream &o) const
 {
     o << "Props Assembly: \n";
     if (pd->m_Prop)
@@ -429,7 +428,7 @@ void Prop3D::PrintSelf(std::ostream &o) const
     pd->m_Renderers->PrintSelf(o,vtkIndent(1));
 }
 
-void Prop3D::ShowBoundingBox(bool show)
+void Puppet::ShowBoundingBox(bool show)
 {
     if (pd->m_ShowBoundingBox == show) return;
     pd->m_ShowBoundingBox = show;
@@ -465,7 +464,7 @@ void Prop3D::ShowBoundingBox(bool show)
     }
 }
 
-void Prop3D::ShowScaleMeasures(bool show)
+void Puppet::ShowScaleMeasures(bool show)
 {
     if (pd->m_ShowScaleMeasures == show) return;
     pd->m_ShowScaleMeasures = show;
@@ -499,13 +498,13 @@ void Prop3D::ShowScaleMeasures(bool show)
     }
 }
 
-void Prop3D::SetRepresentation(Representation mode)
+void Puppet::SetRepresentation(Representation mode)
 {
     pd->m_Representation = static_cast<int>(mode);
     pd->ApplyAppearance(pd->m_Prop);
 }
 
-void Prop3D::SetRepresentation(const char *mode)
+void Puppet::SetRepresentation(const char *mode)
 {
     std::string s(mode);
     if (s == "points") SetRepresentation(Points);
@@ -517,7 +516,7 @@ void Prop3D::SetRepresentation(const char *mode)
     else if (s == "slice") SetRepresentation(Slice);
 }
 
-void Prop3D::SetColor(double r, double g, double b)
+void Puppet::SetColor(double r, double g, double b)
 {
     pd->m_Color[0] = r;
     pd->m_Color[1] = g;
@@ -525,7 +524,7 @@ void Prop3D::SetColor(double r, double g, double b)
     pd->ApplyAppearance(pd->m_Prop);
 }
 
-void Prop3D::SetOpacity(double alpha)
+void Puppet::SetOpacity(double alpha)
 {
     pd->m_Opacity = alpha;
     pd->ApplyAppearance(pd->m_Prop);
@@ -537,18 +536,18 @@ void Prop3D::SetOpacity(double alpha)
 
 
 
-void Prop3D::SetSelectable(bool selectable)
+void Puppet::SetSelectable(bool selectable)
 {
     pd->m_Selectable = selectable;
     pd->ApplyAppearance(pd->m_Prop);
 }
 
-bool Prop3D::IsSelectable() const
+bool Puppet::IsSelectable() const
 {
     return pd->m_Selectable;
 }
 
-void Prop3D::SetSelected(bool selected)
+void Puppet::SetSelected(bool selected)
 {
     if (!pd->m_Selectable) return;
     if (pd->m_Selected == selected) return;
@@ -556,60 +555,33 @@ void Prop3D::SetSelected(bool selected)
     pd->UpdateHighlight();
 }
 
-bool Prop3D::IsSelected() const
+bool Puppet::IsSelected() const
 {
     return pd->m_Selected;
 }
 
-void Prop3D::ApplyProp3DTransform(vtkProp3D* prop)
+void Puppet::Update()
 {
-    if (!prop) return;
+    // Derived classes should have updated the transform if they override Update()
-    if (auto* content = this->GetContent()) {
+    // or we can apply base transform if it's default:
-        if (auto* tr = dynamic_cast<uLib::TRS*>(content)) {
+    // pd->ApplyTransform(pd->m_Prop);
-            vtkNew<vtkMatrix4x4> m;
-            Matrix4fToVtk(tr->GetMatrix(), m);
-            prop->SetUserMatrix(m);
-            prop->Modified();
-        }
-    }
-}
 
-void Prop3D::SyncFromVtk()
+    pd->ApplyAppearance(pd->m_Prop);
-{
-    if (auto* content = this->GetContent()) {
-        if (auto* tr = dynamic_cast<uLib::TRS*>(content)) {
-            if (auto* proxy = this->GetProxyProp()) {
-                if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
-                    tr->FromMatrix(VtkToMatrix4f(mat));
-                    content->Updated();
-                }
-            }
-        }
-    }
-}
-
-void Prop3D::Update()
-{
-    // Apply content transform via virtual GetProp() / ApplyProp3DTransform(),
-    // so all derived classes benefit without duplicating the matrix code.
-    this->ApplyProp3DTransform(vtkProp3D::SafeDownCast(this->GetProp()));
-
-    // Use virtual GetProp() for appearance so overriders (e.g. VoxImage)
-    // that never call SetProp() are handled correctly.
-    pd->ApplyAppearance(this->GetProp());
 
     if (pd->m_Selected) {
         pd->UpdateHighlight();
     }
     
-    if (auto* prop = this->GetProp()) {
+    if (pd->m_Prop) {
-        if (pd->m_ShowBoundingBox && pd->m_OutlineSource) {
+        if (pd->m_ShowBoundingBox) {
-            double* bounds = prop->GetBounds();
+            double* bounds = pd->m_Prop->GetBounds();
             pd->m_OutlineSource->SetBounds(bounds);
             pd->m_OutlineSource->Update();
         }
-        if (pd->m_ShowScaleMeasures && pd->m_CubeAxesActor) {
+        
-            pd->m_CubeAxesActor->SetBounds(prop->GetBounds());
+        if (pd->m_ShowScaleMeasures) {
+            double* bounds = pd->m_Prop->GetBounds();
+            pd->m_CubeAxesActor->SetBounds(bounds);
         }
     }
 
@@ -626,7 +598,7 @@ void Prop3D::Update()
 }
 
 
-void Prop3D::ConnectInteractor(vtkRenderWindowInteractor *interactor)
+void Puppet::ConnectInteractor(vtkRenderWindowInteractor *interactor)
 {
 }
 
@@ -638,7 +610,7 @@ void Prop3D::ConnectInteractor(vtkRenderWindowInteractor *interactor)
 
 
 struct TransformProxy {
-    Prop3DData* pd;
+    PuppetData* pd;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int version) {
         ar & boost::serialization::make_nvp("Transform", pd->m_Transform);
@@ -646,7 +618,7 @@ struct TransformProxy {
 };
 
 struct AppearanceProxy {
-    Prop3DData* pd;
+    PuppetData* pd;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int version) {
         ar & boost::serialization::make_hrp("Color", pd->m_Color, "color");
@@ -661,7 +633,7 @@ struct AppearanceProxy {
     }
 };
 
-void Prop3D::serialize_display(Archive::display_properties_archive & ar, const unsigned int version) {
+void Puppet::serialize_display(Archive::display_properties_archive & ar, const unsigned int version) {
     AppearanceProxy appearance{pd};
     ar & boost::serialization::make_nvp("Appearance", appearance);
     

src/Vtk/uLibVtkInterface.h

@@ -35,8 +35,6 @@
 #include <iomanip>
 #include <ostream>
 #include <vector>
-#include <set>
-#include <boost/type_traits/is_base_of.hpp>
 
 // vtk classes forward declaration //
 class vtkProp;
@@ -52,7 +50,7 @@ namespace Archive {
 class display_properties_archive;
 }
 namespace Vtk {
-class Prop3D;
+class Puppet;
 class Viewer;
 } // namespace Vtk
 } // namespace uLib
@@ -60,13 +58,12 @@ class Viewer;
 namespace uLib {
 namespace Vtk {
 
-class Prop3D : public uLib::Object {
+class Puppet : public uLib::Object {
 
-uLibTypeMacro(Prop3D, uLib::Object)
+uLibTypeMacro(Puppet, uLib::Object)
 
-public:
+    public : Puppet();
-  Prop3D();
+  virtual ~Puppet();
-  virtual ~Prop3D();
 
   virtual vtkProp *GetProp();
   virtual vtkProp3D *GetProxyProp();
@@ -109,7 +106,7 @@ public:
    * 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();
+  virtual void SyncFromVtk() {}
 
   enum Representation {
     Points = 0,
@@ -130,10 +127,10 @@ public:
 
   vtkRendererCollection *GetRenderers() const;
 
-  const std::vector<uLib::PropertyBase *> &GetDisplayProperties() const override {
+  const std::vector<uLib::PropertyBase *> &GetDisplayProperties() const {
     return m_DisplayProperties;
   }
-  void RegisterDisplayProperty(uLib::PropertyBase *prop) override {
+  void RegisterDisplayProperty(uLib::PropertyBase *prop) {
     m_DisplayProperties.push_back(prop);
   }
 
@@ -150,28 +147,23 @@ protected:
 
   void RemoveProp(vtkProp *prop);
 
-  virtual void ApplyAppearance(vtkProp *prop);
+  void ApplyAppearance(vtkProp *prop);
-  virtual void ApplyTransform(vtkProp3D *p3d);
+  void ApplyTransform(vtkProp3D *p3d);
-  virtual void ApplyProp3DTransform(vtkProp3D *p3d);
 
   std::vector<uLib::PropertyBase *> m_DisplayProperties;
   mutable uLib::RecursiveMutex m_UpdateMutex;
 
 private:
-  Prop3D(const Prop3D &) = delete;
+  Puppet(const Puppet &) = delete;
-  Prop3D &operator=(const Prop3D &) = delete;
+  Puppet &operator=(const Puppet &) = delete;
 
-  friend class Prop3DData;
+  friend class PuppetData;
-  class Prop3DData *pd;
+  class PuppetData *pd;
 };
 
 } // namespace Vtk
 } // namespace uLib
 
-
-
-
-
 // -------------------------------------------------------------------------- //
 // DISPLAY PROPERTIES SERIALIZE
 // -------------------------------------------------------------------------- //
@@ -181,23 +173,16 @@ namespace Archive {
 
 /**
  * @brief Specialized archive for registering display-only properties in
- * Prop3Ds.
+ * Puppets.
  */
 class display_properties_archive
     : public boost::archive::detail::common_oarchive<
           display_properties_archive> {
 public:
-  friend class boost::archive::detail::interface_oarchive<display_properties_archive>;
+  display_properties_archive(Vtk::Puppet *puppet)
-  friend class boost::archive::save_access;
-
-  using boost::archive::detail::common_oarchive<display_properties_archive>::save_override;
-  display_properties_archive(Vtk::Prop3D *p)
       : boost::archive::detail::common_oarchive<display_properties_archive>(
             boost::archive::no_header),
-        m_Prop3D(p) {
+        m_Puppet(puppet) {}
-    if (p)
-      m_Visited.insert(dynamic_cast<const void *>(p));
-  }
 
   std::string GetCurrentGroup() const {
     std::string group;
@@ -210,9 +195,9 @@ public:
   }
 
   template <class T> void save_override(const boost::serialization::hrp<T> &t) {
-    if (m_Prop3D) {
+    if (m_Puppet) {
       uLib::Property<T> *p = new uLib::Property<T>(
-          m_Prop3D, t.name(),
+          m_Puppet, t.name(),
           &const_cast<boost::serialization::hrp<T> &>(t).value(),
           t.units() ? t.units() : "", GetCurrentGroup());
       if (t.has_range())
@@ -220,24 +205,24 @@ public:
       if (t.has_default())
         p->SetDefault(t.default_val());
 
-      m_Prop3D->RegisterDisplayProperty(p);
+      m_Puppet->RegisterDisplayProperty(p);
-      Vtk::Prop3D *prop3d = m_Prop3D;
+      Vtk::Puppet *puppet = m_Puppet;
       uLib::Object::connect(p, &uLib::PropertyBase::Updated,
-                            [prop3d]() { prop3d->Update(); });
+                            [puppet]() { puppet->Update(); });
     }
   }
 
   template <class T>
   void save_override(const boost::serialization::hrp_enum<T> &t) {
-    if (m_Prop3D) {
+    if (m_Puppet) {
       uLib::EnumProperty *p = new uLib::EnumProperty(
-          m_Prop3D, t.name(),
+          m_Puppet, t.name(),
           (int *)&const_cast<boost::serialization::hrp_enum<T> &>(t).value(),
           t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
-      m_Prop3D->RegisterDisplayProperty(p);
+      m_Puppet->RegisterDisplayProperty(p);
-      Vtk::Prop3D *prop3d = m_Prop3D;
+      Vtk::Puppet *puppet = m_Puppet;
       uLib::Object::connect(p, &uLib::PropertyBase::Updated,
-                            [prop3d]() { prop3d->Update(); });
+                            [puppet]() { puppet->Update(); });
     }
   }
 
@@ -249,24 +234,6 @@ public:
       m_GroupStack.pop_back();
   }
 
-  // Follow pointers to discover properties in child objects
-  template<class T>
-  void save_override(T * const & t) {
-      if (!t) return;
-      this->save_pointer_helper(t, typename boost::is_base_of<uLib::Object, T>::type());
-  }
-
-  template<class T>
-  void save_pointer_helper(T* t, boost::mpl::true_) {
-      const void* ptr = dynamic_cast<const void*>(t);
-      if (m_Visited.find(ptr) != m_Visited.end()) return;
-      m_Visited.insert(ptr);
-      this->save_override(*t);
-  }
-
-  template<class T>
-  void save_pointer_helper(T* t, boost::mpl::false_) {}
-
   // 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());
@@ -276,8 +243,6 @@ public:
     boost::serialization::serialize_adl(*this, const_cast<T &>(t), 0);
   }
 
-  void save_helper(const std::string &t, boost::mpl::true_) {}
-
   template <class T> void save_helper(const T &t, boost::mpl::false_) {}
 
   void save_override(const boost::archive::object_id_type &t) {}
@@ -289,30 +254,14 @@ public:
   void save_override(const boost::archive::class_name_type &t) {}
   void save_override(const boost::archive::tracking_type &t) {}
 
-  // Called by Property<T>::serialize() and EnumProperty::serialize() to
-  // directly register an existing property object as a display property.
-  void register_property(uLib::PropertyBase &p) {
-    if (m_Prop3D) {
-      m_Prop3D->RegisterDisplayProperty(&p);
-      Vtk::Prop3D *prop3d = m_Prop3D;
-      uLib::Object::connect(&p, &uLib::PropertyBase::Updated,
-                            [prop3d]() { prop3d->Update(); });
-    }
-  }
-
-  void register_enum_property(uLib::EnumProperty &p) {
-    register_property(p);
-  }
-
 private:
-  Vtk::Prop3D *m_Prop3D;
+  Vtk::Puppet *m_Puppet;
   std::vector<std::string> m_GroupStack;
-  std::set<const void *> m_Visited;
 };
 
 } // namespace Archive
 
-// This macro MUST be defined after both Prop3D and display_properties_archive
+// This macro MUST be defined after both Puppet and display_properties_archive
 // are fully defined.
 #define ULIB_ACTIVATE_DISPLAY_PROPERTIES                                       \
   {                                                                            \

src/Vtk/vtkHandlerWidget.cpp

@@ -85,12 +85,12 @@ struct HandlerWidgetData {
   }
 };
 
-vtkStandardNewMacro(HandlerWidget);
+vtkStandardNewMacro(vtkHandlerWidget);
 
-HandlerWidget::HandlerWidget() : d(new HandlerWidgetData()) {
+vtkHandlerWidget::vtkHandlerWidget() : d(new HandlerWidgetData()) {
   this->Interaction = IDLE;
   d->m_Picker->SetTolerance(0.01); // Increased tolerance for thin gizmos
-  this->EventCallbackCommand->SetCallback(HandlerWidget::ProcessEvents);
+  this->EventCallbackCommand->SetCallback(vtkHandlerWidget::ProcessEvents);
   this->EventCallbackCommand->SetClientData(this);
   this->m_Frame = LOCAL;
   d->m_OverlayRenderer->SetLayer(1);
@@ -103,17 +103,17 @@ HandlerWidget::HandlerWidget() : d(new HandlerWidgetData()) {
   this->CreateGizmos();
 }
 
-HandlerWidget::~HandlerWidget() {
+vtkHandlerWidget::~vtkHandlerWidget() {
   this->SetEnabled(0);
   delete d;
 }
 
-::vtkRenderer *HandlerWidget::GetOverlayRenderer() {
+::vtkRenderer *vtkHandlerWidget::GetOverlayRenderer() {
   return d->m_OverlayRenderer;
 }
 
 
-void HandlerWidget::SetProp3D(::vtkProp3D *prop) {
+void vtkHandlerWidget::SetProp3D(::vtkProp3D *prop) {
   if (this->Prop3D == prop) {
     return;
   }
@@ -125,7 +125,7 @@ void HandlerWidget::SetProp3D(::vtkProp3D *prop) {
   this->Modified();
 }
 
-void HandlerWidget::SetEnabled(int enabling) {
+void vtkHandlerWidget::SetEnabled(int enabling) {
   if (enabling) {
     if (this->Enabled)
       return;
@@ -210,15 +210,15 @@ void HandlerWidget::SetEnabled(int enabling) {
   }
 }
 
-void HandlerWidget::ProcessEvents(::vtkObject *caller, unsigned long event,
+void vtkHandlerWidget::ProcessEvents(::vtkObject *caller, unsigned long event,
                                      void *clientdata, void *calldata) {
   (void)caller;
   (void)calldata;
-  HandlerWidget *self = reinterpret_cast<HandlerWidget *>(clientdata);
+  vtkHandlerWidget *self = reinterpret_cast<vtkHandlerWidget *>(clientdata);
   switch (event) {
   case ::vtkCommand::LeftButtonPressEvent:
     self->OnLeftButtonDown();
-    if (self->Interaction != ::uLib::Vtk::HandlerWidget::IDLE)
+    if (self->Interaction != ::uLib::Vtk::vtkHandlerWidget::IDLE)
       self->EventCallbackCommand->SetAbortFlag(1);
     break;
   case ::vtkCommand::LeftButtonReleaseEvent:
@@ -229,7 +229,7 @@ void HandlerWidget::ProcessEvents(::vtkObject *caller, unsigned long event,
     break;
   case ::vtkCommand::MouseMoveEvent:
     self->OnMouseMove();
-    if (self->Interaction != ::uLib::Vtk::HandlerWidget::IDLE)
+    if (self->Interaction != ::uLib::Vtk::vtkHandlerWidget::IDLE)
       self->EventCallbackCommand->SetAbortFlag(1);
     break;
   case ::vtkCommand::RenderEvent:
@@ -241,7 +241,7 @@ void HandlerWidget::ProcessEvents(::vtkObject *caller, unsigned long event,
   }
 }
 
-void HandlerWidget::OnKeyPress() {
+void vtkHandlerWidget::OnKeyPress() {
   std::string key = this->Interactor->GetKeySym();
   bool ctrl = (this->Interactor->GetControlKey() != 0);
   
@@ -268,7 +268,7 @@ void HandlerWidget::OnKeyPress() {
   }
 }
 
-void HandlerWidget::OnLeftButtonDown() {
+void vtkHandlerWidget::OnLeftButtonDown() {
   int X = this->Interactor->GetEventPosition()[0];
   int Y = this->Interactor->GetEventPosition()[1];
 
@@ -322,7 +322,7 @@ void HandlerWidget::OnLeftButtonDown() {
   }
 }
 
-void HandlerWidget::OnLeftButtonUp() {
+void vtkHandlerWidget::OnLeftButtonUp() {
   if (this->Interaction == IDLE)
     return;
 
@@ -332,7 +332,7 @@ void HandlerWidget::OnLeftButtonUp() {
   this->Interactor->Render();
 }
 
-void HandlerWidget::OnMouseMove() {
+void vtkHandlerWidget::OnMouseMove() {
   if (!this->Prop3D || !this->CurrentRenderer)
     return;
 
@@ -564,37 +564,37 @@ void HandlerWidget::OnMouseMove() {
   this->Interactor->Render();
 }
 
-void HandlerWidget::SetReferenceFrame(ReferenceFrame frame) {
+void vtkHandlerWidget::SetReferenceFrame(ReferenceFrame frame) {
   this->m_Frame = frame;
   this->UpdateGizmoPosition();
   if (this->Interactor)
     this->Interactor->Render();
 }
 
-void HandlerWidget::PlaceWidget(double bounds[6]) {
+void vtkHandlerWidget::PlaceWidget(double bounds[6]) {
   (void)bounds;
   this->UpdateGizmoPosition();
 }
 
-void HandlerWidget::SetTranslationEnabled(bool enabled) {
+void vtkHandlerWidget::SetTranslationEnabled(bool enabled) {
   this->m_TranslationEnabled = enabled;
   this->UpdateVisibility();
   if (this->Interactor) this->Interactor->Render();
 }
 
-void HandlerWidget::SetRotationEnabled(bool enabled) {
+void vtkHandlerWidget::SetRotationEnabled(bool enabled) {
   this->m_RotationEnabled = enabled;
   this->UpdateVisibility();
   if (this->Interactor) this->Interactor->Render();
 }
 
-void HandlerWidget::SetScalingEnabled(bool enabled) {
+void vtkHandlerWidget::SetScalingEnabled(bool enabled) {
   this->m_ScalingEnabled = enabled;
   this->UpdateVisibility();
   if (this->Interactor) this->Interactor->Render();
 }
 
-void HandlerWidget::UpdateVisibility() {
+void vtkHandlerWidget::UpdateVisibility() {
     if (!d->m_AxesX) return;
     
     d->m_AxesX->SetVisibility(m_TranslationEnabled);
@@ -633,22 +633,22 @@ void HandlerWidget::UpdateVisibility() {
     }
 }
 
-void HandlerWidget::PlaceWidget() { this->UpdateGizmoPosition(); }
+void vtkHandlerWidget::PlaceWidget() { this->UpdateGizmoPosition(); }
 
-void HandlerWidget::SetTransform(::vtkTransform *t) {
+void vtkHandlerWidget::SetTransform(::vtkTransform *t) {
   if (!t || !this->Prop3D)
     return;
   this->Prop3D->SetUserMatrix(t->GetMatrix());
   this->UpdateGizmoPosition();
 }
 
-void HandlerWidget::GetTransform(::vtkTransform *t) {
+void vtkHandlerWidget::GetTransform(::vtkTransform *t) {
   if (!t || !this->Prop3D)
     return;
   t->SetMatrix(this->Prop3D->GetMatrix());
 }
 
-void HandlerWidget::CreateGizmos() {
+void vtkHandlerWidget::CreateGizmos() {
   auto create_arrow = [](double dir[3], double color[3]) {
     auto arrow = vtkSmartPointer<::vtkArrowSource>::New();
     arrow->SetTipLength(0.2);
@@ -756,7 +756,7 @@ void HandlerWidget::CreateGizmos() {
   d->m_Picker->PickFromListOn();
 }
 
-void HandlerWidget::UpdateGizmoPosition() {
+void vtkHandlerWidget::UpdateGizmoPosition() {
   if (!this->Prop3D)
     return;
 
@@ -909,7 +909,7 @@ void HandlerWidget::UpdateGizmoPosition() {
   }
 }
 
-void HandlerWidget::Highlight(::vtkProp *prop) {
+void vtkHandlerWidget::Highlight(::vtkProp *prop) {
   if (this->d->m_HighlightedProp == prop)
     return;
 

src/Vtk/vtkHandlerWidget.h

@@ -26,7 +26,7 @@
 #ifndef U_VTKHANDLERWIDGET_H
 #define U_VTKHANDLERWIDGET_H
 
-#include "Vtk/Math/vtkDense.h"
+#include "Math/Dense.h"
 #include "uLibVtkInterface.h"
 
 #include <vtk3DWidget.h>
@@ -48,16 +48,16 @@ namespace uLib {
 namespace Vtk {
 
 /**
- * @class HandlerWidget
+ * @class vtkHandlerWidget
  * @brief A Blender-like transform gizmo for move, rotate, and scale.
  */
-class HandlerWidget : public ::vtk3DWidget {
+class vtkHandlerWidget : public ::vtk3DWidget {
 public:
-  static HandlerWidget *New();
+  static vtkHandlerWidget *New();
-  vtkTypeMacro(HandlerWidget, ::vtk3DWidget);
+  vtkTypeMacro(vtkHandlerWidget, ::vtk3DWidget);
 
-  HandlerWidget();
+  vtkHandlerWidget();
-  virtual ~HandlerWidget();
+  virtual ~vtkHandlerWidget();
 
   virtual void SetEnabled(int enabling) override;
   static void ProcessEvents(::vtkObject *caller, unsigned long event,
@@ -134,8 +134,8 @@ public:
   void OnKeyPress();
 
 private:
-  HandlerWidget(const HandlerWidget &) = delete;
+  vtkHandlerWidget(const vtkHandlerWidget &) = delete;
-  void operator=(const HandlerWidget &) = delete;
+  void operator=(const vtkHandlerWidget &) = delete;
 };
 
 } // namespace Vtk

src/Vtk/vtkMuonContainerScattering.h

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

src/Vtk/vtkObjectsContext.cpp

@@ -4,43 +4,35 @@
 #include "Vtk/Math/vtkAssembly.h"
 #include "Vtk/Math/vtkVoxImage.h"
 
-#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
+#include "HEP/Detectors/vtkDetectorChamber.h"
-#include "Vtk/HEP/Geant/vtkBoxSolid.h"
+#include "HEP/Geant/vtkBoxSolid.h"
 
 #include <vtkAssembly.h>
 #include <vtkPropCollection.h>
 #include <iostream>
 #include <cstring>
 
-#include "Math/ContainerBox.h"
-#include "Math/Cylinder.h"
-#include "Math/Assembly.h"
-#include "Math/VoxImage.h"
-#include "HEP/Detectors/DetectorChamber.h"
-#include "HEP/Geant/Solid.h"
-
-
 namespace uLib {
 namespace Vtk {
 
-ObjectsContext::ObjectsContext(uLib::ObjectsContext *context)
+vtkObjectsContext::vtkObjectsContext(uLib::ObjectsContext *context)
     : m_Context(context), m_Assembly(::vtkAssembly::New()) {
   this->SetProp(m_Assembly);
   if (m_Context) {
-    Object::connect(m_Context, &uLib::ObjectsContext::ObjectAdded, this, &ObjectsContext::OnObjectAdded);
+    Object::connect(m_Context, &uLib::ObjectsContext::ObjectAdded, this, &vtkObjectsContext::OnObjectAdded);
-    Object::connect(m_Context, &uLib::ObjectsContext::ObjectRemoved, this, &ObjectsContext::OnObjectRemoved);
+    Object::connect(m_Context, &uLib::ObjectsContext::ObjectRemoved, this, &vtkObjectsContext::OnObjectRemoved);
     this->Synchronize();
   }
 }
 
-ObjectsContext::~ObjectsContext() {
+vtkObjectsContext::~vtkObjectsContext() {
-  for (auto const& [obj, prop3d] : m_Prop3Ds) {
+  for (auto const& [obj, puppet] : m_Puppets) {
-    delete prop3d;
+    delete puppet;
   }
   m_Assembly->Delete();
 }
 
-void ObjectsContext::Synchronize() {
+void vtkObjectsContext::Synchronize() {
   if (!m_Context) return;
 
   // 1. Identify objects to add and remove
@@ -48,112 +40,112 @@ void ObjectsContext::Synchronize() {
   std::map<uLib::Object*, bool> currentObjects;
   for (auto obj : objects) currentObjects[obj] = true;
 
-  // Remove Prop3Ds for objects no longer in context
+  // Remove puppets for objects no longer in context
-  for (auto it = m_Prop3Ds.begin(); it != m_Prop3Ds.end(); ) {
+  for (auto it = m_Puppets.begin(); it != m_Puppets.end(); ) {
     if (currentObjects.find(it->first) == currentObjects.end()) {
-      it->second->DisconnectRenderer(nullptr); // If we have a ref to a renderer we should disconnect but Prop3D doesn't store it easily
+      it->second->DisconnectRenderer(nullptr); // If we have a ref to a renderer we should disconnect but Puppet doesn't store it easily
-      // Actually Prop3D::DisconnectRenderer(vtkRenderer*) needs the renderer.
+      // Actually Puppet::DisconnectRenderer(vtkRenderer*) needs the renderer.
       // For now we just remove from assembly
       if (auto* p3d = vtkProp3D::SafeDownCast(it->second->GetProp()))
           m_Assembly->RemovePart(p3d);
-      this->Prop3DRemoved(it->second);
+      this->PuppetRemoved(it->second);
       delete it->second;
-      it = m_Prop3Ds.erase(it);
+      it = m_Puppets.erase(it);
     } else {
       ++it;
     }
   }
 
-  // Add Prop3Ds for new objects
+  // Add puppets for new objects
   for (auto obj : objects) {
-    if (m_Prop3Ds.find(obj) == m_Prop3Ds.end()) {
+    if (m_Puppets.find(obj) == m_Puppets.end()) {
-      Prop3D* prop3d = this->CreateProp3D(obj);
+      Puppet* puppet = this->CreatePuppet(obj);
-      if (prop3d) {
+      if (puppet) {
-        m_Prop3Ds[obj] = prop3d;
+        m_Puppets[obj] = puppet;
-        if (auto* p3d = vtkProp3D::SafeDownCast(prop3d->GetProp()))
+        if (auto* p3d = vtkProp3D::SafeDownCast(puppet->GetProp()))
             m_Assembly->AddPart(p3d);
-        this->Prop3DAdded(prop3d);
+        this->PuppetAdded(puppet);
       }
     }
   }
 }
 
-void ObjectsContext::OnObjectAdded(uLib::Object* obj) {
+void vtkObjectsContext::OnObjectAdded(uLib::Object* obj) {
   if (!obj) return;
-  if (m_Prop3Ds.find(obj) == m_Prop3Ds.end()) {
+  if (m_Puppets.find(obj) == m_Puppets.end()) {
-    Prop3D* prop3d = this->CreateProp3D(obj);
+    Puppet* puppet = this->CreatePuppet(obj);
-    if (prop3d) {
+    if (puppet) {
-      m_Prop3Ds[obj] = prop3d;
+      m_Puppets[obj] = puppet;
-      if (auto* p3d = vtkProp3D::SafeDownCast(prop3d->GetProp()))
+      if (auto* p3d = vtkProp3D::SafeDownCast(puppet->GetProp()))
           m_Assembly->AddPart(p3d);
-      this->Prop3DAdded(prop3d);
+      this->PuppetAdded(puppet);
     }
   }
 }
 
-void ObjectsContext::OnObjectRemoved(uLib::Object* obj) {
+void vtkObjectsContext::OnObjectRemoved(uLib::Object* obj) {
   if (!obj) return;
-    auto it = m_Prop3Ds.find(obj);
+    auto it = m_Puppets.find(obj);
-    if (it != m_Prop3Ds.end()) {
+    if (it != m_Puppets.end()) {
         // For now we just remove from assembly. 
-        // Prop3D::DisconnectRenderer(vtkRenderer*) needs the renderer, but we don't have it here easily.
+        // Puppet::DisconnectRenderer(vtkRenderer*) needs the renderer, but we don't have it here easily.
         if (auto* p3d = vtkProp3D::SafeDownCast(it->second->GetProp()))
             m_Assembly->RemovePart(p3d);
-        this->Prop3DRemoved(it->second);
+        this->PuppetRemoved(it->second);
         delete it->second;
-        m_Prop3Ds.erase(it);
+        m_Puppets.erase(it);
     }
 }
 
-Prop3D* ObjectsContext::GetProp3D(uLib::Object* obj) {
+Puppet* vtkObjectsContext::GetPuppet(uLib::Object* obj) {
-  auto it = m_Prop3Ds.find(obj);
+  auto it = m_Puppets.find(obj);
-  if (it != m_Prop3Ds.end()) return it->second;
+  if (it != m_Puppets.end()) return it->second;
   return nullptr;
 }
 
-void ObjectsContext::Update() {
+void vtkObjectsContext::Update() {
-  for (auto const& [obj, prop3d] : m_Prop3Ds) {
+  for (auto const& [obj, puppet] : m_Puppets) {
-    prop3d->Update();
+    puppet->Update();
   }
 }
 
-void ObjectsContext::SyncFromVtk() {
+void vtkObjectsContext::SyncFromVtk() {
-  for (auto const& [obj, prop3d] : m_Prop3Ds) {
+  for (auto const& [obj, puppet] : m_Puppets) {
-    prop3d->SyncFromVtk();
+    puppet->SyncFromVtk();
   }
 }
 
-Prop3D* ObjectsContext::CreateProp3D(uLib::Object* obj) {
+Puppet* vtkObjectsContext::CreatePuppet(uLib::Object* obj) {
   if (!obj) return nullptr;
 
   if (auto* vox = dynamic_cast<uLib::Abstract::VoxImage*>(obj)) {
-    return new VoxImage(*vox);
+    return new vtkVoxImage(*vox);
   } else if (auto* box = dynamic_cast<uLib::ContainerBox*>(obj)) {
-    return new ContainerBox(box);
+    return new vtkContainerBox(box);
   } else if (auto* chamber = dynamic_cast<uLib::DetectorChamber*>(obj)) {
-    return new DetectorChamber(chamber);
+    return new vtkDetectorChamber(chamber);
   } else if (auto* cylinder = dynamic_cast<uLib::Cylinder*>(obj)) {
-    return new Cylinder(cylinder);
+    return new vtkCylinder(cylinder);
   } else if (auto* assembly = dynamic_cast<uLib::Assembly*>(obj)) {
     return new Assembly(assembly);
   } else if (auto* box = dynamic_cast<uLib::Geant::BoxSolid*>(obj)) {
-    return new BoxSolid(box);
+    return new vtkBoxSolid(box);
   }
   
   // Fallback if we don't know the exact class but it might be a context itself
   if (auto subCtx = dynamic_cast<uLib::ObjectsContext*>(obj)) {
-      return new ObjectsContext(subCtx);
+      return new vtkObjectsContext(subCtx);
   }
 
   return nullptr;
 }
 
-void ObjectsContext::Prop3DAdded(Prop3D* prop3d) {
+void vtkObjectsContext::PuppetAdded(Puppet* puppet) {
-  ULIB_SIGNAL_EMIT(ObjectsContext::Prop3DAdded, prop3d);
+  ULIB_SIGNAL_EMIT(vtkObjectsContext::PuppetAdded, puppet);
 }
 
-void ObjectsContext::Prop3DRemoved(Prop3D* prop3d) {
+void vtkObjectsContext::PuppetRemoved(Puppet* puppet) {
-  ULIB_SIGNAL_EMIT(ObjectsContext::Prop3DRemoved, prop3d);
+  ULIB_SIGNAL_EMIT(vtkObjectsContext::PuppetRemoved, puppet);
 }
 
 } // namespace Vtk

src/Vtk/vtkObjectsContext.h

@@ -11,31 +11,31 @@ namespace uLib {
 namespace Vtk {
 
 /**
- * @brief ObjectsContext manages VTK representations (Prop3Ds) for a collection of uLib::Objects.
+ * @brief vtkObjectsContext manages VTK representations (Puppets) for a collection of uLib::Objects.
  */
-class ObjectsContext : public Prop3D {
+class vtkObjectsContext : public Puppet {
 public:
-  uLibTypeMacro(ObjectsContext, Prop3D)
+  uLibTypeMacro(vtkObjectsContext, Puppet)
-  ObjectsContext(uLib::ObjectsContext *context);
+  vtkObjectsContext(uLib::ObjectsContext *context);
-  virtual ~ObjectsContext();
+  virtual ~vtkObjectsContext();
 
-  /** @brief Synchronizes the VTK prop3ds with the core ObjectsContext. */
+  /** @brief Synchronizes the VTK puppets with the core ObjectsContext. */
   void Synchronize();
 
-  /** @brief Returns the Prop3D associated with a specific core object. */
+  /** @brief Returns the puppet associated with a specific core object. */
-  Prop3D* GetProp3D(uLib::Object* obj);
+  Puppet* GetPuppet(uLib::Object* obj);
 
-  const std::map<uLib::Object*, Prop3D*>& GetProp3Ds() const { return m_Prop3Ds; }
+  const std::map<uLib::Object*, Puppet*>& GetPuppets() const { return m_Puppets; }
 
-  /** @brief Updates all managed prop3ds. */
+  /** @brief Updates all managed puppets. */
   virtual void Update() override;
 
-  /** @brief Synchronizes all managed prop3ds back to their models. */
+  /** @brief Synchronizes all managed puppets back to their models. */
   virtual void SyncFromVtk() override;
 
   public:
-  virtual void Prop3DAdded(Prop3D* prop3d);
+  virtual void PuppetAdded(Puppet* puppet);
-  virtual void Prop3DRemoved(Prop3D* prop3d);
+  virtual void PuppetRemoved(Puppet* puppet);
 
   public:
   /** @brief Slot called when an object is added to the core context. */
@@ -44,12 +44,12 @@ public:
   void OnObjectRemoved(uLib::Object* obj);
 
 protected:
-  /** @brief Factory method to create a Prop3D for a core object. */
+  /** @brief Factory method to create a puppet for a core object. */
-  Prop3D* CreateProp3D(uLib::Object* obj);
+  Puppet* CreatePuppet(uLib::Object* obj);
 
 private:
   uLib::ObjectsContext *m_Context;
-  std::map<uLib::Object*, Prop3D*> m_Prop3Ds;
+  std::map<uLib::Object*, Puppet*> m_Puppets;
   vtkAssembly *m_Assembly;
 };
 

src/Vtk/vtkQViewport.cpp

@@ -136,9 +136,9 @@ void QViewport::onProjButtonClicked()
     SetParallelProjection(m_ProjButton->isChecked());
 }
 
-void QViewport::OnSelectionChanged(Prop3D* p)
+void QViewport::OnSelectionChanged(Puppet* p)
 {
-    emit prop3dSelected(p);
+    emit puppetSelected(p);
 }
 
 void QViewport::resizeEvent(QResizeEvent* event)

src/Vtk/vtkQViewport.h

@@ -26,12 +26,12 @@ namespace Vtk {
 /**
  * QViewport is a self-contained Qt widget that embeds a VTK renderer
  * directly into the Qt application (no separate VTK window).
- * Prop3Ds and actors are added to the embedded renderer.
+ * Puppets and actors are added to the embedded renderer.
  */
 class QViewport : public QWidget, public Viewport {
     Q_OBJECT
 signals:
-    void prop3dSelected(uLib::Vtk::Prop3D* p);
+    void puppetSelected(uLib::Vtk::Puppet* p);
 public:
     explicit QViewport(QWidget* parent = nullptr);
     virtual ~QViewport();
@@ -44,7 +44,7 @@ public:
     virtual vtkRenderWindowInteractor*  GetInteractor() override;
     QVTKOpenGLNativeWidget*     GetWidget()      { return m_VtkWidget; }
 
-    virtual void OnSelectionChanged(Prop3D* p) override;
+    virtual void OnSelectionChanged(Puppet* p) override;
 
 protected:
     virtual void resizeEvent(QResizeEvent* event) override;