OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: OpenCMT:fix-assembly
Branches Tags
OpenCMT:main OpenCMT:fix-properties OpenCMT:gea-devel OpenCMT:fix-context OpenCMT:fix-assembly OpenCMT:andrea-dev OpenCMT:andrea-geo OpenCMT:serialization OpenCMT:andrea-alg OpenCMT:beam_tracer OpenCMT:devel
OpenCMT:v0.5.3 OpenCMT:v0.5.2 OpenCMT:v0.5.1 OpenCMT:v.0.4.1 OpenCMT:v.0.3.1 OpenCMT:v.0.2.1 OpenCMT:v1.0.0
..
compare: OpenCMT:69b47623f83beb4a84293c4b61a8681b052ad1a6
Branches Tags
OpenCMT:fix-properties OpenCMT:gea-devel OpenCMT:fix-context OpenCMT:fix-assembly OpenCMT:andrea-dev OpenCMT:andrea-geo OpenCMT:serialization OpenCMT:andrea-alg OpenCMT:main OpenCMT:beam_tracer OpenCMT:devel
OpenCMT:v0.5.3 OpenCMT:v0.5.2 OpenCMT:v0.5.1 OpenCMT:v.0.4.1 OpenCMT:v.0.3.1 OpenCMT:v.0.2.1 OpenCMT:v1.0.0

2 Commits
fix-assemb ... 69b47623f8

Author SHA1 Message Date
AndreaRigoni
69b47623f8 algorithm on filters 2026-03-27 02:45:40 +00:00
AndreaRigoni
f5c1e317e8 algorithm def 2026-03-27 02:29:56 +00:00
176 changed files with 3220 additions and 5884 deletions
Expand all files Collapse all files

9
.agents/rules/context_exclude_vtk.md
View File

@@ -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.

9
.agents/rules/context_gcompose.md
View File

@@ -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.

9
.agents/rules/context_vtk.md
View File

@@ -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.

7
.agents/rules/micromamba.md Normal file
View File

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

39
.agents/skills/micromamba_build.md
View File

@@ -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)
```

4
.clangd
View File

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

9
.gitignore vendored
View File

@@ -1,7 +1,6 @@
CMakeFiles/
build*/
build/
.cache/
CMakeUserPresets.json
build_warnings*.log
final_build.log
cmake_configure.log
@@ -14,9 +13,3 @@ src/Python/uLib/*.pyd
src/Python/uLib/*.pyc
src/Python/uLib/__pycache__
src/Python/uLib/.nfs*
test_props.xml
test_props2.xml
test_boost.cpp
.claude/settings.json
build_output.log
configure_output.log

3
.vscode/gdb_wrapper.sh vendored
View File

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

31
.vscode/launch.json vendored
View File

@@ -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"
}
]
}

5
.vscode/settings.json vendored
View File

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

17
.vscode/tasks.json vendored
View File

@@ -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"
]
}
]
}

40
CLAUDE.md
View File

@@ -10,9 +10,9 @@ 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)
# Configure (from repo root, using Conan preset)
cmake --preset conan-release
# Build everything
@@ -40,18 +40,6 @@ conan install . --output-folder=build --build=missing
cmake --preset conan-release
```
### Build acceleration (already configured)
- **Ninja** generator — used automatically via the conan default profile (`~/.conan2/profiles/default`)
- **ccache** — enabled via `CMAKE_CXX_COMPILER_LAUNCHER=ccache`; cached rebuilds are nearly instant (~0.3s vs ~25s cold)
- **Clang 22 + lld** profile available (`~/.conan2/profiles/fast`) but blocked by template overload ambiguities in `src/Core/Archives.h` that need fixing for full compatibility
To reconfigure with the fast profile once Archives.h is fixed:
```bash
conan install . --output-folder=build --build=missing --profile=fast
cmake -B build -G Ninja -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)
```
## Architecture
**uLib** is a C++ framework for Cosmic Muon Tomography (CMT), structured as layered shared libraries:
@@ -71,32 +59,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.
- `Viewport`: base class managing the VTK renderer, picking, selection logic. Maintains `m_Prop3Ds` vector and `m_ObjectToProp3D` map.
- `QViewport` (inherits `QWidget` + `Viewport`): Qt-embedded VTK widget. Emits Qt signal `prop3dSelected(Prop3D*)` on click-selection via `OnSelectionChanged`.
- `vtkObjectsContext`: wraps `ObjectsContext`, creating/destroying `Prop3D`s as objects come/go. Emits `Prop3DAdded`/`Prop3DRemoved`.
- 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.
- `Puppet` (inherits `uLib::Object`): wraps a VTK `vtkProp` for rendering. Has `GetContent()` returning the underlying domain object. Display-only properties are registered via `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro.
- `Viewport`: base class managing the VTK renderer, picking, selection logic. Maintains `m_Puppets` vector and `m_ObjectToPuppet` map.
- `QViewport` (inherits `QWidget` + `Viewport`): Qt-embedded VTK widget. Emits Qt signal `puppetSelected(Puppet*)` on click-selection via `OnSelectionChanged`.
- `vtkObjectsContext`: wraps `ObjectsContext`, creating/destroying `Puppet`s as objects come/go. Emits `PuppetAdded`/`PuppetRemoved`.
- Display properties: `serialize_display()` + `display_properties_archive` registers selected `hrp<T>` fields as `PropertyBase*` in the puppet's `m_DisplayProperties`. `PropertyEditor::setObject(obj, displayOnly=true)` shows only those.
### gcompose GUI App (`app/gcompose/src/`)
- `MainPanel`: top-level widget. Owns `ContextPanel` (left) and `ViewportPane` (right). Wires together viewport↔context selection via signals.
- `ContextPanel`: tree view of `ObjectsContext`. Emits `objectSelected(Object*)`. Contains an embedded `PropertiesPanel`.
- `PropertiesPanel`: shows `uLib::Object` properties via `PropertyEditor`.
- `ViewportPane`: embeds `QViewport` + a slide-out "Display Properties" panel (`PropertyEditor` in display-only mode).
- `PropertyEditor`: populates widgets from `Object::GetProperties()` (all) or `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()
→ emit prop3dSelected(p)
Viewport click → Viewport::SelectPuppet() → QViewport::OnSelectionChanged()
→ emit puppetSelected(p)
→ MainPanel: contextPanel->selectObject(p->GetContent()) [updates tree + PropertiesPanel]
→ MainPanel: firstPane->setObject(p) [updates Display Properties panel]
ContextPanel tree click → emit objectSelected(obj)
→ MainPanel: viewport->SelectProp3D(prop3d) [visual selection in VTK]
→ MainPanel: firstPane->setObject(prop3d) [updates Display Properties panel]
→ MainPanel: viewport->SelectPuppet(puppet) [visual selection in VTK]
→ MainPanel: firstPane->setObject(puppet) [updates Display Properties panel]
```
### Key Patterns
- **Two signal systems coexist**: Qt signals (`Q_OBJECT`, `connect(...)`) for GUI; `uLib::Object::connect(...)` for domain signals.
- **Display properties** flow: `Prop3D::serialize_display()` → `display_properties_archive` → `RegisterDisplayProperty()` → `PropertyEditor(displayOnly=true)`. Must call `ULIB_ACTIVATE_DISPLAY_PROPERTIES` in the prop3d constructor.
- **Prop3D ↔ Object map**: `Viewport::m_ObjectToProp3D` allows lookup by domain object; `vtkObjectsContext::GetProp3D(obj)` does the same.
- **Display properties** flow: `Puppet::serialize_display()` → `display_properties_archive` → `RegisterDisplayProperty()` → `PropertyEditor(displayOnly=true)`. Must call `ULIB_ACTIVATE_DISPLAY_PROPERTIES` in the puppet constructor.
- **Puppet ↔ Object map**: `Viewport::m_ObjectToPuppet` allows lookup by domain object; `vtkObjectsContext::GetPuppet(obj)` does the same.

56
CMakeLists.txt
View File

@@ -15,32 +15,11 @@ if(POLICY CMP0167)
cmake_policy(SET CMP0167 NEW)
endif()
## -------------------------------------------------------------------------- ##
project(uLib)
option(ULIB_USE_CCACHE "Use ccache for build acceleration" ON)
if(ULIB_USE_CCACHE)
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
endif()
else()
set(CMAKE_CXX_COMPILER_LAUNCHER "")
set(CMAKE_C_COMPILER_LAUNCHER "")
endif()
# 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)
@@ -59,7 +38,7 @@ endif()
# The version number.
set(PROJECT_VERSION_MAJOR 0)
set(PROJECT_VERSION_MINOR 7)
set(PROJECT_VERSION_MINOR 6)
set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
@@ -142,13 +121,8 @@ find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_fra
include_directories(${Boost_INCLUDE_DIRS})
find_package(Eigen3 CONFIG REQUIRED)
# if(NOT EIGEN3_INCLUDE_DIRS)
# get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
# else()
# include_directories(${EIGEN3_INCLUDE_DIRS})
# endif()
find_package(OpenMP)
get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
include_directories(${EIGEN3_INCLUDE_DIRS})
find_package(ROOT CONFIG REQUIRED)
include(${ROOT_USE_FILE})
@@ -171,8 +145,6 @@ else()
IOXML
IOXMLParser
ImagingCore
ImagingHybrid
ImagingSources
InteractionStyle
InteractionWidgets
RenderingAnnotation
@@ -197,26 +169,6 @@ if(Geant4_FOUND)
add_compile_definitions(HAVE_GEANT4)
set(HAVE_GEANT4 1)
# Workaround: Geant4's G4EXPATShim creates EXPAT::EXPAT (uppercase) with
# IMPORTED_LOCATION "${EXPAT_LIBRARY}", but EXPAT_LIBRARY is empty when using
# conda's config-mode expat package (which installs as expat::expat lowercase).
# Resolve the actual library path from expat::expat or via find_library.
if(TARGET EXPAT::EXPAT)
get_target_property(_expat_loc EXPAT::EXPAT IMPORTED_LOCATION)
if(NOT _expat_loc OR _expat_loc MATCHES "NOTFOUND|^$")
if(TARGET expat::expat)
get_target_property(_expat_loc expat::expat IMPORTED_LOCATION_NOCONFIG)
endif()
if(NOT _expat_loc OR _expat_loc MATCHES "NOTFOUND|^$")
find_library(_expat_loc NAMES expat)
endif()
if(_expat_loc)
set_target_properties(EXPAT::EXPAT PROPERTIES IMPORTED_LOCATION "${_expat_loc}")
endif()
endif()
unset(_expat_loc)
endif()
# Sanitize Geant4 targets to remove Qt5 dependencies that conflict with VTK/Qt6
if(TARGET Geant4::G4interfaces)
set_target_properties(Geant4::G4interfaces PROPERTIES

24
CMakePresets.json
View File

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

9
CMakeUserPresets.json Normal file
View File

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

54
README.md
View File

@@ -30,22 +30,18 @@ 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
#### Standard build (GCC + Ninja + ccache)
The default conan profile uses **Ninja** as the generator and **ccache** for compiler caching, dramatically speeding up incremental rebuilds.
1. **Configure Conan profile (first time only):**
1. **Configure Conan profile (if you haven't yet on your machine):**
```bash
conan profile detect
```
@@ -55,54 +51,20 @@ conan profile detect
conan install . --output-folder=build --build=missing
```
3. **Configure with CMake:**
3. **Configure the project with CMake:**
```bash
cmake --preset conan-release
```
*(Alternatively: `cd build && cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release`)*
4. **Build:**
4. **Build the project:**
```bash
cmake --build build -j$(nproc)
cmake --build build -j10
```
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
```
Then build using the `fast` profile:
```bash
conan install . --output-folder=build --build=missing --profile=fast
cmake -B build -G Ninja \
-DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake \
-DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)
```
The `fast` profile is defined at `~/.conan2/profiles/fast` and sets:
- `CMAKE_C_COMPILER=clang` / `CMAKE_CXX_COMPILER=clang++`
- `CMAKE_EXE_LINKER_FLAGS=-fuse-ld=lld`
- `CMAKE_CXX_COMPILER_LAUNCHER=ccache`
### Make python package
```bash
micromamba run -n uLib env USE_CUDA=ON poetry install
micromamba run -n mutom env USE_CUDA=ON poetry install
```

2
app/gcompose/CMakeLists.txt
View File

@@ -17,8 +17,6 @@ add_executable(gcompose
src/PropertyWidgets.cpp
src/PropertiesPanel.h
src/PropertiesPanel.cpp
src/PreferencesDialog.h
src/PreferencesDialog.cpp
)
set_target_properties(gcompose PROPERTIES

141
app/gcompose/src/ContextModel.cpp
View File

@@ -4,11 +4,6 @@
#include <cxxabi.h>
#include <functional>
#include "Core/Object.h"
#include <QMimeData>
#include <QDataStream>
#include <QIODevice>
#include <vector>
#include <algorithm>
ContextModel::ContextModel(QObject* parent)
: QAbstractItemModel(parent), m_rootContext(nullptr) {}
@@ -16,16 +11,12 @@ ContextModel::ContextModel(QObject* parent)
ContextModel::~ContextModel() {}
void ContextModel::setContext(uLib::ObjectsContext* context) {
m_isReseting = true;
beginResetModel();
m_rootContext = context;
if (m_rootContext) {
auto refresh = [this]() {
if (this->m_isReseting) return;
this->m_isReseting = true;
this->beginResetModel();
this->endResetModel();
this->m_isReseting = false;
};
uLib::Object::connect(m_rootContext, &uLib::Object::Updated, refresh);
@@ -34,6 +25,7 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
refresh();
});
uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectRemoved, [this, refresh](uLib::Object* obj) {
// Disconnect would be good here but not strictly required if refresh handles it
refresh();
});
@@ -43,7 +35,6 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
}
}
endResetModel();
m_isReseting = false;
}
QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent) const {
@@ -57,8 +48,8 @@ QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent)
}
} else {
uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
uLib::ObjectsContext* parentCtx = parentObj->GetChildren();
if (parentCtx && row < (int)parentCtx->GetCount()) {
uLib::ObjectsContext* parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
if (parentCtx && row < parentCtx->GetCount()) {
return createIndex(row, column, parentCtx->GetObject(row));
}
}
@@ -74,37 +65,36 @@ QModelIndex ContextModel::parent(const QModelIndex& child) const {
// Finding the parent of childObj is O(N) since there is no parent pointer.
// We just do a recursive search starting from root context.
std::function<uLib::Object*(uLib::Object*, uLib::Object*)> findParent =
[&findParent](uLib::Object* current, uLib::Object* target) -> uLib::Object* {
uLib::ObjectsContext* ctx = current->GetChildren();
if (ctx) {
for (const auto& obj : ctx->GetObjects()) {
if (obj == target) return current;
if (auto p = findParent(obj, target)) return p;
std::function<uLib::ObjectsContext*(uLib::ObjectsContext*, uLib::Object*)> findParent =
[&findParent](uLib::ObjectsContext* ctx, uLib::Object* target) -> uLib::ObjectsContext* {
for (const auto& obj : ctx->GetObjects()) {
if (obj == target) return ctx;
if (auto subCtx = dynamic_cast<uLib::ObjectsContext*>(obj)) {
if (auto p = findParent(subCtx, target)) return p;
}
}
return nullptr;
};
uLib::Object* parentObj = findParent(m_rootContext, childObj);
if (!parentObj || parentObj == m_rootContext) {
uLib::ObjectsContext* parentCtx = findParent(m_rootContext, childObj);
if (!parentCtx || parentCtx == m_rootContext) {
return QModelIndex(); // Root items have invalid parent index
}
// Now need to find the row of parentObj in its own parent Context.
uLib::Object* grandParentObj = findParent(m_rootContext, parentObj);
uLib::ObjectsContext* grandParentCtx = grandParentObj ? grandParentObj->GetChildren() : m_rootContext;
// Now need to find the row of parentCtx in its own parent Context.
uLib::ObjectsContext* grandParentCtx = findParent(m_rootContext, parentCtx);
if (!grandParentCtx) grandParentCtx = m_rootContext;
int row = -1;
for (size_t i = 0; i < grandParentCtx->GetCount(); ++i) {
if (grandParentCtx->GetObject(i) == parentObj) {
if (grandParentCtx->GetObject(i) == parentCtx) {
row = (int)i;
break;
}
}
if (row != -1) {
return createIndex(row, 0, parentObj);
return createIndex(row, 0, parentCtx);
}
return QModelIndex();
}
@@ -117,8 +107,8 @@ int ContextModel::rowCount(const QModelIndex& parent) const {
}
uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
if (auto parentCtx = parentObj->GetChildren()) {
return (int)parentCtx->GetCount();
if (auto parentCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj)) {
return parentCtx->GetCount();
}
return 0; // leaf node
}
@@ -148,7 +138,6 @@ QVariant ContextModel::data(const QModelIndex& index, int role) const {
if (!index.isValid()) return QVariant();
uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
if (!obj) return QVariant();
if (role == Qt::DisplayRole) {
QString typeName = getDemangledName(typeid(*obj));
@@ -172,98 +161,8 @@ QVariant ContextModel::headerData(int section, Qt::Orientation orientation, int
}
Qt::ItemFlags ContextModel::flags(const QModelIndex& index) const {
if (!index.isValid()) return m_rootContext ? Qt::ItemIsDropEnabled : Qt::NoItemFlags;
Qt::ItemFlags f = Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
if (dynamic_cast<uLib::ObjectsContext*>(obj)) {
f |= Qt::ItemIsDropEnabled;
}
return f;
}
Qt::DropActions ContextModel::supportedDropActions() const {
return Qt::MoveAction;
}
QStringList ContextModel::mimeTypes() const {
return {"application/x-ulib-object-ptr"};
}
QMimeData* ContextModel::mimeData(const QModelIndexList& indexes) const {
QMimeData* mimeData = new QMimeData();
QByteArray encodedData;
QDataStream stream(&encodedData, QIODevice::WriteOnly);
for (const auto& idx : indexes) {
if (idx.isValid() && idx.column() == 0) {
void* ptr = idx.internalPointer();
stream << reinterpret_cast<qlonglong>(ptr);
}
}
mimeData->setData("application/x-ulib-object-ptr", encodedData);
return mimeData;
}
bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) {
if (action != Qt::MoveAction || !data->hasFormat("application/x-ulib-object-ptr")) return false;
uLib::ObjectsContext* targetCtx = m_rootContext;
if (parent.isValid()) {
uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
targetCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
}
if (!targetCtx) return false;
QByteArray encodedData = data->data("application/x-ulib-object-ptr");
QDataStream stream(&encodedData, QIODevice::ReadOnly);
std::vector<uLib::Object*> objectsToMove;
while (!stream.atEnd()) {
qlonglong ptrVal;
stream >> ptrVal;
objectsToMove.push_back(reinterpret_cast<uLib::Object*>(ptrVal));
}
if (objectsToMove.empty()) return false;
// Helper to find and remove from current parent
std::function<void(uLib::Object*, uLib::Object*)> findAndRemoveRecursive =
[&findAndRemoveRecursive](uLib::Object* current, uLib::Object* target) {
if (auto ctx = current->GetChildren()) {
ctx->RemoveObject(target);
for (auto* obj : ctx->GetObjects()) {
findAndRemoveRecursive(obj, target);
}
}
};
m_isReseting = true;
beginResetModel();
for (auto* obj : objectsToMove) {
// Don't drop onto itself or its descendants
bool invalid = (obj == targetCtx || obj == (uLib::Object*)targetCtx);
if (!invalid) {
// check if targetCtx is descendant of obj
std::function<bool(uLib::Object*, uLib::Object*)> isDescendant =
[&isDescendant](uLib::Object* root, uLib::Object* target) -> bool {
if (auto ctx = root->GetChildren()) {
for (auto* child : ctx->GetObjects()) {
if (child == target) return true;
if (isDescendant(child, target)) return true;
}
}
return false;
};
if (isDescendant(obj, (uLib::Object*)targetCtx)) invalid = true;
}
if (!invalid) {
findAndRemoveRecursive(m_rootContext, obj);
targetCtx->AddObject(obj);
}
}
endResetModel();
m_isReseting = false;
return true;
if (!index.isValid()) return Qt::NoItemFlags;
return Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
}
bool ContextModel::setData(const QModelIndex& index, const QVariant& value, int role) {

7
app/gcompose/src/ContextModel.h
View File

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

4
app/gcompose/src/ContextPanel.cpp
View File

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

76
app/gcompose/src/MainPanel.cpp
View File

@@ -13,14 +13,11 @@
#include <QPushButton>
#include <QMenu>
#include <QAction>
#include <QShortcut>
#include <QApplication>
#include <QFileDialog>
#include <QFileInfo>
#include "StyleManager.h"
#include "Math/VoxImage.h"
#include "PreferencesDialog.h"
#include "Settings.h"
MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr) {
this->setObjectName("MainPanel");
@@ -48,12 +45,17 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
fileMenu->addAction("Open", this, &MainPanel::onOpen);
fileMenu->addAction("Save", this, &MainPanel::onSave);
fileMenu->addAction("Save As", this, &MainPanel::onSaveAs);
fileMenu->addSeparator();
fileMenu->addAction("Preferences", this, &MainPanel::onPreferences);
fileMenu->addSeparator();
fileMenu->addAction("Exit", this, &MainPanel::onExit);
btnFile->setMenu(fileMenu);
// Theme Menu Button
auto* btnTheme = new QPushButton("Theme", menuPanel);
btnTheme->setObjectName("MenuButton");
auto* themeMenu = new QMenu(btnTheme);
themeMenu->addAction("Dark", this, &MainPanel::onDarkTheme);
themeMenu->addAction("Bright", this, &MainPanel::onBrightTheme);
btnTheme->setMenu(themeMenu);
// New Menu Button
auto* btnNew = new QPushButton("Add", menuPanel);
btnNew->setObjectName("MenuButton");
@@ -71,6 +73,7 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
menuLayout->addWidget(logo);
menuLayout->addWidget(btnFile);
menuLayout->addWidget(btnNew);
menuLayout->addWidget(btnTheme);
menuLayout->addStretch();
mainLayout->addWidget(menuPanel);
@@ -87,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);
// Update the display properties in the viewport pane itself - use the prop3d proxy if possible
m_firstPane->setObject(prop3d ? (uLib::Object*)prop3d : obj);
viewport->SelectPuppet(puppet);
// Update the display properties in the viewport pane itself - use the puppet proxy if possible
m_firstPane->setObject(puppet ? (uLib::Object*)puppet : obj);
} else {
m_firstPane->setObject(obj);
}
@@ -105,14 +108,6 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
m_rootSplitter->setSizes(sizes);
mainLayout->addWidget(m_rootSplitter, 1);
// Shortcuts
auto* groupShortcut = new QShortcut(QKeySequence("Ctrl+G"), this);
connect(groupShortcut, &QShortcut::activated, [this]() {
if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
viewport->GroupSelection(m_context);
}
});
}
void MainPanel::setContext(uLib::ObjectsContext* context) {
@@ -121,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;
@@ -129,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);
// viewport->AddProp3D(*m_mainVtkContext); // redundant
m_mainVtkContext = new uLib::Vtk::vtkObjectsContext(context);
// 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);
@@ -141,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();
}
@@ -156,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);
}
}
}
@@ -241,21 +236,12 @@ void MainPanel::onExit() {
qApp->quit();
}
void MainPanel::onPreferences() {
uLib::Qt::PreferencesDialog dlg(this);
if (dlg.exec() == QDialog::Accepted) {
// Apply theme
auto theme = uLib::Qt::Settings::Instance().GetTheme();
StyleManager::applyStyle(qApp, theme == uLib::Qt::Settings::Dark ? "dark" : "bright");
void MainPanel::onDarkTheme() {
StyleManager::applyStyle(qApp, "dark");
}
// Apply rendering preference to all viewports
bool throttled = uLib::Qt::Settings::Instance().GetThrottledRendering();
auto viewports = this->findChildren<uLib::Vtk::QViewport*>();
for (auto* vp : viewports) {
vp->SetThrottledRendering(throttled);
vp->Render();
}
}
void MainPanel::onBrightTheme() {
StyleManager::applyStyle(qApp, "bright");
}
MainPanel::~MainPanel() {}

7
app/gcompose/src/MainPanel.h
View File

@@ -11,7 +11,7 @@ class PropertiesPanel;
namespace uLib {
class ObjectsContext;
namespace Vtk {
class ObjectsContext;
class vtkObjectsContext;
}
}
@@ -30,7 +30,8 @@ private slots:
void onSaveAs();
void onExit();
void onPreferences();
void onDarkTheme();
void onBrightTheme();
void onCreateObject(const std::string& className);
@@ -39,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

99
app/gcompose/src/PreferencesDialog.cpp
View File

@@ -1,99 +0,0 @@
#include "PreferencesDialog.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QFormLayout>
#include <QPushButton>
#include <QLabel>
#include <QGroupBox>
namespace uLib {
namespace Qt {
PreferencesDialog::PreferencesDialog(QWidget* parent) : QDialog(parent) {
setWindowTitle("Preferences");
setMinimumWidth(400);
auto* mainLayout = new QVBoxLayout(this);
mainLayout->setSpacing(20);
mainLayout->setContentsMargins(20, 20, 20, 20);
// ── General / Rendering Settings ────────────────────────────────────────
auto* renderingGroup = new QGroupBox("Appearance & Performance", this);
auto* renderingLayout = new QVBoxLayout(renderingGroup);
auto* themeLayout = new QHBoxLayout();
themeLayout->addWidget(new QLabel("Color Theme:"));
m_themeCombo = new QComboBox(renderingGroup);
m_themeCombo->addItem("Dark");
m_themeCombo->addItem("Bright");
m_themeCombo->setCurrentIndex(Settings::Instance().GetTheme() == Settings::Dark ? 0 : 1);
themeLayout->addWidget(m_themeCombo);
themeLayout->addStretch();
renderingLayout->addLayout(themeLayout);
renderingLayout->addSpacing(10);
m_throttledRendering = new QCheckBox("Enable throttled rendering (recommended for performance)", renderingGroup);
m_throttledRendering->setChecked(Settings::Instance().GetThrottledRendering());
m_throttledRendering->setToolTip("Limits framerate to ~60fps to reduce CPU/GPU usage.");
renderingLayout->addWidget(m_throttledRendering);
mainLayout->addWidget(renderingGroup);
// ── Units Settings ──────────────────────────────────────────────────────
auto* unitsGroup = new QGroupBox("Preferred Units", this);
auto* unitsLayout = new QFormLayout(unitsGroup);
unitsLayout->setLabelAlignment(::Qt::AlignRight);
unitsLayout->setSpacing(10);
auto addUnitRow = [&](const QString& label, Settings::Dimension dim, const QStringList& units) {
auto* combo = new QComboBox(unitsGroup);
combo->addItems(units);
std::string current = Settings::Instance().GetPreferredUnit(dim);
int idx = combo->findText(QString::fromStdString(current));
if (idx >= 0) combo->setCurrentIndex(idx);
unitsLayout->addRow(label + ":", combo);
m_unitCombos[dim] = combo;
};
addUnitRow("Length", Settings::Length, {"m", "cm", "mm", "um", "nm"});
addUnitRow("Angle", Settings::Angle, {"deg", "rad"});
addUnitRow("Energy", Settings::Energy, {"MeV", "GeV", "eV", "keV", "TeV"});
addUnitRow("Time", Settings::Time, {"ns", "s", "ms", "us"});
mainLayout->addWidget(unitsGroup);
mainLayout->addStretch();
// ── Buttons ─────────────────────────────────────────────────────────────
auto* buttonLayout = new QHBoxLayout();
buttonLayout->addStretch();
auto* btnCancel = new QPushButton("Cancel", this);
connect(btnCancel, &QPushButton::clicked, this, &QDialog::reject);
auto* btnOk = new QPushButton("Apply", this);
btnOk->setDefault(true);
btnOk->setObjectName("DisplayToggleBtn"); // Reusing high-contrast style
btnOk->setMinimumWidth(100);
connect(btnOk, &QPushButton::clicked, this, &PreferencesDialog::onAccept);
buttonLayout->addWidget(btnCancel);
buttonLayout->addWidget(btnOk);
mainLayout->addLayout(buttonLayout);
}
void PreferencesDialog::onAccept() {
Settings::Instance().SetThrottledRendering(m_throttledRendering->isChecked());
Settings::Instance().SetTheme(m_themeCombo->currentIndex() == 0 ? Settings::Dark : Settings::Bright);
for (auto const& pair : m_unitCombos) {
Settings::Instance().SetPreferredUnit(pair.first, pair.second->currentText().toStdString());
}
accept();
}
} // namespace Qt
} // namespace uLib

31
app/gcompose/src/PreferencesDialog.h
View File

@@ -1,31 +0,0 @@
#ifndef GCOMPOSE_PREFERENCESDIALOG_H
#define GCOMPOSE_PREFERENCESDIALOG_H
#include <QDialog>
#include <QCheckBox>
#include <QComboBox>
#include <map>
#include <string>
#include "Settings.h"
namespace uLib {
namespace Qt {
class PreferencesDialog : public QDialog {
Q_OBJECT
public:
explicit PreferencesDialog(QWidget* parent = nullptr);
private slots:
void onAccept();
private:
QCheckBox* m_throttledRendering;
QComboBox* m_themeCombo;
std::map<Settings::Dimension, QComboBox*> m_unitCombos;
};
} // namespace Qt
} // namespace uLib
#endif

126
app/gcompose/src/PropertyWidgets.cpp
View File

@@ -7,10 +7,6 @@
#include "Vtk/uLibVtkInterface.h"
#include "Math/Units.h"
#include "Math/Dense.h"
#include <QPushButton>
#include <QColorDialog>
#include <QFrame>
#include <QSlider>
#include "Settings.h"
namespace uLib {
@@ -23,7 +19,7 @@ PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent)
std::string unit = prop->GetUnits();
QString labelText = QString::fromStdString(prop->GetName());
if (!unit.empty() && unit != "color") {
if (!unit.empty()) {
auto dim = Settings::Instance().IdentifyDimension(unit);
std::string pref = Settings::Instance().GetPreferredUnit(dim);
if (!pref.empty()) {
@@ -36,8 +32,6 @@ PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent)
m_Label = new QLabel(labelText, this);
m_Label->setMinimumWidth(120);
m_Layout->addWidget(m_Label);
this->setEnabled(!prop->IsReadOnly());
}
PropertyWidgetBase::~PropertyWidgetBase() {
m_Connection.disconnect();
@@ -51,7 +45,7 @@ double parseWithUnits(const QString& text, double* factorOut, QString* suffixOut
double num = match.captured(1).toDouble();
QString unit = match.captured(3);
double factor = factorOut ? *factorOut : 1.0;
double factor = 1.0;
if (!unit.isEmpty()) {
QString u = unit.startsWith('_') ? unit.mid(1) : unit;
@@ -107,6 +101,10 @@ void UnitLineEdit::onEditingFinished() {
double factor = m_Factor;
QString suffix = m_Suffix;
double parsedVal = parseWithUnits(text(), &factor, &suffix);
if (!suffix.isEmpty()) {
m_Suffix = suffix;
m_Factor = factor;
}
if (m_IsInteger) {
parsedVal = std::round(parsedVal);
}
@@ -152,7 +150,7 @@ DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* pare
m_Edit->setValue(prop->Get());
m_Layout->addWidget(m_Edit, 1);
connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
m_Connection = uLib::Object::connect(m_Prop, &Property<double>::PropertyChanged, [this](){
m_Edit->setValue(m_Prop->Get());
});
}
@@ -170,7 +168,7 @@ FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
m_Edit->setValue(prop->Get());
m_Layout->addWidget(m_Edit, 1);
connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((float)val); });
m_Connection = uLib::Object::connect(m_Prop, &Property<float>::Updated, [this](){
m_Connection = uLib::Object::connect(m_Prop, &Property<float>::PropertyChanged, [this](){
m_Edit->setValue((double)m_Prop->Get());
});
}
@@ -189,7 +187,7 @@ IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
m_Edit->setValue(prop->Get());
m_Layout->addWidget(m_Edit, 1);
connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((int)val); });
m_Connection = uLib::Object::connect(m_Prop, &Property<int>::Updated, [this](){
m_Connection = uLib::Object::connect(m_Prop, &Property<int>::PropertyChanged, [this](){
m_Edit->setValue((double)m_Prop->Get());
});
}
@@ -200,7 +198,7 @@ BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
m_CheckBox->setChecked(prop->Get());
m_Layout->addWidget(m_CheckBox, 1);
connect(m_CheckBox, &QCheckBox::toggled, [this](bool val){ if (m_Prop->Get() != val) m_Prop->Set(val); });
m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::Updated, [this](){
m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::PropertyChanged, [this](){
if (m_CheckBox->isChecked() != m_Prop->Get()) {
QSignalBlocker blocker(m_CheckBox);
m_CheckBox->setChecked(m_Prop->Get());
@@ -209,76 +207,6 @@ BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
}
BoolPropertyWidget::~BoolPropertyWidget() {}
RangePropertyWidget::RangePropertyWidget(Property<double>* prop, QWidget* parent)
: PropertyWidgetBase(prop, parent), m_Prop(prop) {
m_Slider = new QSlider(::Qt::Horizontal, this);
m_Slider->setRange(0, 100);
m_Slider->setMinimumWidth(80);
m_Edit = new UnitLineEdit(this);
m_Edit->setFixedWidth(50);
m_Layout->addWidget(m_Slider, 1);
m_Layout->addWidget(m_Edit, 0);
connect(m_Slider, &QSlider::valueChanged, this, &RangePropertyWidget::onSliderChanged);
connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
this->updateUi();
});
updateUi();
}
RangePropertyWidget::~RangePropertyWidget() { m_Connection.disconnect(); }
void RangePropertyWidget::updateUi() {
double val = m_Prop->Get();
m_Edit->setValue(val);
if (m_Prop->GetMax() != m_Prop->GetMin()) {
int sliderVal = (int)((val - m_Prop->GetMin()) / (m_Prop->GetMax() - m_Prop->GetMin()) * 100.0);
QSignalBlocker blocker(m_Slider);
m_Slider->setValue(sliderVal);
}
}
void RangePropertyWidget::onSliderChanged(int val) {
double realVal = m_Prop->GetMin() + (val / 100.0) * (m_Prop->GetMax() - m_Prop->GetMin());
m_Prop->Set(realVal);
}
ColorPropertyWidget::ColorPropertyWidget(Property<Vector3d>* prop, QWidget* parent)
: PropertyWidgetBase(prop, parent), m_Prop(prop) {
m_Button = new QPushButton(this);
m_Button->setFixedWidth(60);
this->updateButtonColor();
m_Layout->addWidget(m_Button, 0, ::Qt::AlignRight);
connect(m_Button, &QPushButton::clicked, this, &ColorPropertyWidget::onClicked);
m_Connection = uLib::Object::connect(m_Prop, &Property<Vector3d>::Updated, [this](){
this->updateButtonColor();
});
}
ColorPropertyWidget::~ColorPropertyWidget() {}
void ColorPropertyWidget::updateButtonColor() {
Vector3d c = m_Prop->Get();
QColor color = QColor::fromRgbF(std::max(0.0, std::min(1.0, c.x())),
std::max(0.0, std::min(1.0, c.y())),
std::max(0.0, std::min(1.0, c.z())));
m_Button->setStyleSheet(QString("background-color: %1; border: 1px solid #555; height: 18px;").arg(color.name()));
}
void ColorPropertyWidget::onClicked() {
Vector3d c = m_Prop->Get();
QColor current = QColor::fromRgbF(std::max(0.0, std::min(1.0, c.x())),
std::max(0.0, std::min(1.0, c.y())),
std::max(0.0, std::min(1.0, c.z())));
QColor selected = QColorDialog::getColor(current, this, "Select Color");
if (selected.isValid()) {
m_Prop->Set(Vector3d(selected.redF(), selected.greenF(), selected.blueF()));
}
}
StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget* parent)
: PropertyWidgetBase(prop, parent), m_Prop(prop) {
m_LineEdit = new QLineEdit(this);
@@ -288,7 +216,7 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
std::string val = m_LineEdit->text().toStdString();
if (m_Prop->Get() != val) m_Prop->Set(val);
});
m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::Updated, [this](){
m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::PropertyChanged, [this](){
if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
QSignalBlocker blocker(m_LineEdit);
m_LineEdit->setText(QString::fromStdString(m_Prop->Get()));
@@ -336,7 +264,7 @@ public:
p->Set(index);
});
// Store connection in base m_Connection so it's auto-disconnected on destruction.
m_Connection = uLib::Object::connect(p, &Property<int>::Updated, [this, p](){
m_Connection = uLib::Object::connect(p, &Property<int>::PropertyChanged, [this, p](){
if (m_Combo->currentIndex() != p->Get()) {
QSignalBlocker blocker(m_Combo);
m_Combo->setCurrentIndex(p->Get());
@@ -403,10 +331,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)) {
props = &prop3d->GetDisplayProperties();
if (auto* puppet = dynamic_cast<::uLib::Vtk::Puppet*>(obj)) {
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.
}
}
@@ -434,31 +362,19 @@ void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
// Priority 1: Check if it provides enum labels
if (!prop->GetEnumLabels().empty()) {
widget = new EnumPropertyWidget(prop, m_Container);
} else if (prop->GetUnits() == "color") {
// Color Picker for Vector3d
if (auto* pvec = dynamic_cast<Property<Vector3d>*>(prop)) {
widget = new ColorPropertyWidget(pvec, m_Container);
}
} else if (prop->HasRange()) {
// Slider for ranged doubles
if (auto* pdbl = dynamic_cast<Property<double>*>(prop)) {
widget = new RangePropertyWidget(pdbl, m_Container);
} else if (auto* pflt = dynamic_cast<Property<float>*>(prop)) {
// widget = new RangePropertyWidget<float>(pflt, m_Container);
}
} else {
// Priority 2: Standard factory lookup
auto it = m_Factories.find(prop->GetTypeIndex());
if (it != m_Factories.end()) {
widget = it->second(prop, m_Container);
} else {
auto it = m_Factories.find(prop->GetTypeIndex());
if (it != m_Factories.end()) {
widget = it->second(prop, m_Container);
} else {
// Debug info for unknown types
std::cout << "PropertyEditor: No factory for " << prop->GetQualifiedName()
<< " (Type: " << prop->GetTypeName() << ")" << std::endl;
widget = new PropertyWidgetBase(prop, m_Container);
widget = new PropertyWidgetBase(prop, m_Container);
widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
}
}
}
if (widget) {

32
app/gcompose/src/PropertyWidgets.h
View File

@@ -2,8 +2,6 @@
#define PROPERTY_WIDGETS_H
#include <QWidget>
class QPushButton;
class QSlider;
#include <QLabel>
#include <QHBoxLayout>
#include <QVBoxLayout>
@@ -115,7 +113,6 @@ public:
if (!prefSuffix.isEmpty()) {
m_Edits[i]->setUnits(prefSuffix, factor);
}
m_Edits[i]->setEnabled(!prop->IsReadOnly());
m_Layout->addWidget(m_Edits[i], 1);
connect(m_Edits[i], &UnitLineEdit::valueManualChanged, [this, i](double val){
@@ -125,7 +122,7 @@ public:
});
}
updateEdits();
m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::Updated, [this](){
m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::PropertyChanged, [this](){
updateEdits();
});
}
@@ -144,20 +141,6 @@ private:
UnitLineEdit* m_Edits[Size];
};
class RangePropertyWidget : public PropertyWidgetBase {
Q_OBJECT
public:
RangePropertyWidget(Property<double>* prop, QWidget* parent = nullptr);
virtual ~RangePropertyWidget();
private slots:
void onSliderChanged(int val);
private:
void updateUi();
Property<double>* m_Prop;
QSlider* m_Slider;
UnitLineEdit* m_Edit;
};
class BoolPropertyWidget : public PropertyWidgetBase {
Q_OBJECT
public:
@@ -168,19 +151,6 @@ private:
QCheckBox* m_CheckBox;
};
class ColorPropertyWidget : public PropertyWidgetBase {
Q_OBJECT
public:
ColorPropertyWidget(Property<Vector3d>* prop, QWidget* parent = nullptr);
virtual ~ColorPropertyWidget();
private slots:
void onClicked();
private:
void updateButtonColor();
Property<Vector3d>* m_Prop;
QPushButton* m_Button;
};
class StringPropertyWidget : public PropertyWidgetBase {
Q_OBJECT
public:

25
app/gcompose/src/QViewportPane.cpp
View File

@@ -88,14 +88,14 @@ 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.
}
void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
if (m_viewport) {
// Use deleteLater() instead of delete to avoid crashes during repaint cycles
m_viewport->deleteLater();
m_viewport->parentWidget()->layout()->removeWidget(m_viewport);
delete m_viewport;
}
m_viewport = viewport;
m_titleLabel->setText(title);
@@ -105,8 +105,21 @@ void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
mainAreaLayout->insertWidget(0, m_viewport);
}
QViewportPane::~QViewportPane() {}
void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
if (m_viewport) {
m_layout->removeWidget(m_viewport);
delete m_viewport;
}
m_viewport = viewport;
m_titleLabel->setText(title);
m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_layout->addWidget(m_viewport);
}
void QViewportPane::addVtkViewport() {
auto* viewport = new uLib::Vtk::QViewport(this);
setViewport(viewport, "VTK Viewport");
@@ -166,9 +179,9 @@ void QViewportPane::AttemptSplit(Qt::Orientation orientation) {
if (currentVtk) {
auto* newVtk = qobject_cast<uLib::Vtk::QViewport*>(newPane->currentViewport());
if (newVtk) {
// Copy prop3ds
for (auto* prop3d : currentVtk->getProp3Ds()) {
newVtk->AddProp3D(*prop3d);
// Copy puppets
for (auto* puppet : currentVtk->getPuppets()) {
newVtk->AddPuppet(*puppet);
}
// Copy camera
if (currentVtk->GetRenderer() && newVtk->GetRenderer()) {

15
app/gcompose/src/Settings.h
View File

@@ -23,11 +23,6 @@ public:
Dimensionless
};
enum Theme {
Dark,
Bright
};
void SetPreferredUnit(Dimension dim, const std::string& unit) {
m_PreferredUnits[dim] = unit;
}
@@ -69,17 +64,9 @@ public:
return Dimensionless;
}
bool GetThrottledRendering() const { return m_ThrottledRendering; }
void SetThrottledRendering(bool enabled) { m_ThrottledRendering = enabled; }
Theme GetTheme() const { return m_Theme; }
void SetTheme(Theme theme) { m_Theme = theme; }
private:
Settings() : m_ThrottledRendering(true), m_Theme(Dark) {}
Settings() {}
std::map<Dimension, std::string> m_PreferredUnits;
bool m_ThrottledRendering;
Theme m_Theme;
};
} // namespace Qt

16
app/gcompose/src/ViewportPane.cpp
View File

@@ -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)
bool isProp3D = (dynamic_cast<::uLib::Vtk::Prop3D*>(obj) != nullptr);
// Check if the object is a Puppet (meaning it has display properties)
bool isPuppet = (dynamic_cast<::uLib::Vtk::Puppet*>(obj) != nullptr);
// Only show the "Display" toggle button if it's a prop3d
m_toggleBtn->setVisible(isProp3D);
// Only show the "Display" toggle button if it's a puppet
m_toggleBtn->setVisible(isPuppet);
// If it's a prop3d, 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.
if (!isProp3D) {
// If it's a puppet, we might want to keep the panel state if it was already open,
// or if it's NOT a puppet, definitely hide the toggle and panel.
if (!isPuppet) {
m_toggleBtn->setChecked(false);
m_displayPanel->hide();
}
@@ -115,7 +115,7 @@ void ViewportPane::setObject(uLib::Object* obj) {
void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
if (m_viewport) {
m_viewport->deleteLater();
delete m_viewport;
}
m_viewport = viewport;
m_titleLabel->setText(title);

37
build.log
View File

@@ -1 +1,36 @@
ninja: error: loading 'build.ninja': No such file or directory
make: Entering directory '/home/rigoni/devel/cmt/ulib/build'
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxImage.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/TriangleMesh.cpp.o
[ 30%] Building CXX object src/Core/CMakeFiles/mutomCore.dir/Options.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Dense.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredGrid.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxRaytracer.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredData.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured2DGrid.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured4DGrid.cpp.o
[ 33%] Linking CXX shared library libmutomCore.so
[ 33%] Built target mutomCore
[ 36%] Linking CXX shared library libmutomMath.so
[ 36%] Built target mutomMath
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkContainerBox.cpp.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkInterface.cxx.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkStructuredGrid.cpp.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkMuonScatter.cxx.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkViewer.cpp.o
[ 63%] Generating mutomRootDict.cxx, libmutomRootDict_rdict.pcm, libmutomRootDict.rootmap
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxImage.cpp.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxRaytracerRepresentation.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorSkinHit.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorHit.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMCTrack.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorInfo.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/RootMuonScatter.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorPrimaryVertex.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMuDetDIGI.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/SkinDetectorWriter.cpp.o
[ 93%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/mutomRootDict.cxx.o
[ 96%] Linking CXX shared library libmutomVtk.so
[ 96%] Built target mutomVtk
[100%] Linking CXX shared library libmutomRoot.so
[100%] Built target mutomRoot
make: Leaving directory '/home/rigoni/devel/cmt/ulib/build'

4
conanfile.txt
View File

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

15
condaenv.yml
View File

@@ -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
- pybind11
#- boost=1.86.0 # requested by VTK 9.4
- ninja
- clang
- clangxx
- lld
- ccache
- OpenMP
- Geant4
- gdb
- valgrind
- vtk

7
docs/algorithms/algoritm.md Normal file
View File

@@ -0,0 +1,7 @@
# Aggoritm definition
An algorithm in the uLib infrastructure is a class for containing a functional that can be dynamically loaded into memory as a plug-in.
It derives from the base Object class and therefore can contain properties that define the serialization of operating parameters or the implementation of widgets for interactive parameter manipulation.
The algorithm class is designed to be inserted into a Task, i.e., a class for managing the execution of scheduled operations. A task contains a Run and Stop method to start and stop execution. Furthermore, a task can be configured to work in cyclic or asynchronous mode: in cyclic mode it will be possible to define a cycle time, while in asynchronous mode a task can be hooked to a signal-slot of the Object structure or to a condition variable defined in the monitor pattern (Monitor.h).
The algorithm in particular is defined as a template class on two types T_enc, T_dec. The encoder is a type for data input or another algorithm that is chained with this one that outputs data in the format compatible with input. The decoder is the type of data output or an algorithm compatible with it.

84
docs/archives.md
View File

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

48
docs/code/vtk/vtk_Prop3D.md
View File

@@ -1,48 +0,0 @@
# Prop3D
`uLib::Vtk::Prop3D` is a bridge class that wraps VTK 3D representations (`vtkProp`, `vtkProp3D`) and integrates them into the `uLib` object model. It allows the framework to manage visual objects, synchronize them with underlying data models, and expose display-specific properties to the GUI.
## Inheritance
`uLib::Vtk::Prop3D` : `uLib::Object`
## Key Functionalities
### VTK Integration
The class provides access to the underlying VTK objects:
- `GetProp()`: Returns the `vtkProp`.
- `GetProxyProp()`: Returns the `vtkProp3D`.
- `GetParts()` / `GetProps()`: Returns `vtkPropCollection` for composite objects.
### Model-View Synchronization
`Prop3D` ensures that the visual representation stays in sync with the domain model:
- `Update()`: Synchronizes the VTK representation based on current internal state and properties. Should be called when model data changes.
- `SyncFromVtk()`: Updates internal state using data from the VTK representation (e.g., after user interaction via gizmos in the 3D view).
- `GetContent()`: Returns the `uLib::Object` that this `Prop3D` represents visually.
### Visual Appearance
- **Color & Opacity**: `SetColor(r, g, b)` and `SetOpacity(alpha)`.
- **Selection**: `SetSelectable(bool)` and `SetSelected(bool)` to manage interactivity and highlighting.
- **BBox/Scale**: `ShowBoundingBox(bool)` and `ShowScaleMeasures(bool)`.
### Rendering Modes
The rendering style can be controlled via the `Representation` enum:
- `Points`
- `Wireframe`
- `Surface`
- `SurfaceWithEdges`
- `Volume`
- `Outline`
- `Slice`
### Display Properties System
`Prop3D` implements a system to expose specific properties (often marked as `hrp` - human readable properties) to a property editor in the GUI.
- `GetDisplayProperties()`: Returns the list of properties registered for display.
- `RegisterDisplayProperty(uLib::PropertyBase*)`: Adds a property to the display list.
- `serialize_display(...)`: A virtual method that subclasses implement to define which properties should be exposed.
#### Activating Display Properties
To automatically populate the display properties list, the `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro should be called in the constructor. This triggers `serialize_display` using a `display_properties_archive`.
## Implementation Details
`Prop3D` uses the Pimpl idiom (via `Prop3DData *pd`) to hide VTK-specific implementation details and reduce header dependencies.

11
docs/geant_integration.md
View File

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

94
docs/update_properties.md
View File

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

234
src/Core/Algorithm.h Normal file
View File

@@ -0,0 +1,234 @@
/*//////////////////////////////////////////////////////////////////////////////
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
All rights reserved
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
------------------------------------------------------------------
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library.
//////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_ALGORITHM_H
#define U_CORE_ALGORITHM_H
#include <atomic>
#include <chrono>
#include <condition_variable>
#include "Core/Object.h"
#include "Core/Monitor.h"
#include "Core/Threads.h"
#include "Core/Property.h"
namespace uLib {
////////////////////////////////////////////////////////////////////////////////
//// ALGORITHM /////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/**
* @brief Algorithm is a template class for containing a functional that can be
* dynamically loaded as a plug-in. It derives from Object and supports
* properties for serialization and interactive parameter widgets.
*
* @tparam T_enc Encoder type: the input data type, or a chained algorithm
* whose output is compatible with this algorithm's input.
* @tparam T_dec Decoder type: the output data type, or a chained algorithm
* whose input is compatible with this algorithm's output.
*/
template <typename T_enc, typename T_dec>
class Algorithm : public Object {
public:
using EncoderType = T_enc;
using DecoderType = T_dec;
Algorithm() : Object(), m_Encoder(nullptr), m_Decoder(nullptr) {}
virtual ~Algorithm() = default;
virtual const char* GetClassName() const override { return "Algorithm"; }
/**
* @brief Process input data and produce output.
* Override this in subclasses to implement the algorithm logic.
*/
virtual T_dec Process(const T_enc& input) = 0;
/**
* @brief Operator form of Process for functional chaining.
*/
T_dec operator()(const T_enc& input) { return Process(input); }
void SetEncoder(Algorithm* enc) { m_Encoder = enc; }
Algorithm* GetEncoder() const { return m_Encoder; }
void SetDecoder(Algorithm* dec) { m_Decoder = dec; }
Algorithm* GetDecoder() const { return m_Decoder; }
signals:
virtual void Started() { ULIB_SIGNAL_EMIT(Algorithm::Started); }
virtual void Finished() { ULIB_SIGNAL_EMIT(Algorithm::Finished); }
protected:
Algorithm* m_Encoder;
Algorithm* m_Decoder;
};
////////////////////////////////////////////////////////////////////////////////
//// ALGORITHM TASK ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/**
* @brief AlgorithmTask manages the execution of an Algorithm within a
* scheduled context. Uses uLib::Thread for execution and uLib::Mutex for
* synchronization. Supports cyclic mode (with configurable period) and
* asynchronous mode (triggered by Object signal-slot or condition variable
* from Monitor.h).
*/
template <typename T_enc, typename T_dec>
class AlgorithmTask : public Thread {
public:
using AlgorithmType = Algorithm<T_enc, T_dec>;
enum Mode { Cyclic, Async };
AlgorithmTask()
: Thread()
, m_Algorithm(nullptr)
, m_Mode(Cyclic)
, m_CycleTime_ms(1000)
, m_StopRequested(false)
, m_Triggered(false)
{}
virtual ~AlgorithmTask() { Stop(); }
virtual const char* GetClassName() const override { return "AlgorithmTask"; }
void SetAlgorithm(AlgorithmType* alg) { m_Algorithm = alg; }
AlgorithmType* GetAlgorithm() const { return m_Algorithm; }
void SetMode(Mode mode) { m_Mode = mode; }
Mode GetMode() const { return m_Mode; }
void SetCycleTime(int milliseconds) { m_CycleTime_ms = milliseconds; }
int GetCycleTime() const { return m_CycleTime_ms; }
/**
* @brief Start the task execution in a separate thread (via Thread::Start).
* In Cyclic mode, the algorithm is executed periodically.
* In Async mode, call Notify() or connect a signal to trigger execution.
*/
void Run(const T_enc& input) {
if (IsRunning()) return;
m_StopRequested.store(false);
m_Triggered.store(false);
m_Input = input;
Start();
}
/**
* @brief Stop the task execution and join the thread.
*/
void Stop() {
m_StopRequested.store(true);
{
ULIB_MUTEX_LOCK(m_WaitMutex, -1) {
m_Condition.notify_all();
}
}
if (IsJoinable()) Join();
}
/**
* @brief Notify the task to execute one iteration (Async mode).
* Can be called from a signal-slot connection or externally.
*/
void Notify() {
m_Triggered.store(true);
ULIB_MUTEX_LOCK(m_WaitMutex, -1) {
m_Condition.notify_one();
}
}
/**
* @brief Connect an Object signal to trigger async execution.
* Usage: task.ConnectTrigger(sender, &SenderClass::SomeSignal);
*/
template <typename Func1>
Connection ConnectTrigger(typename FunctionPointer<Func1>::Object* sender, Func1 sigf) {
return Object::connect(sender, sigf, [this]() { Notify(); });
}
signals:
virtual void Stopped() { ULIB_SIGNAL_EMIT(AlgorithmTask::Stopped); }
protected:
/**
* @brief Thread entry point — dispatches to cyclic or async loop.
*/
void Run() override {
if (m_Mode == Cyclic) {
RunCyclic();
} else {
RunAsync();
}
Stopped();
}
private:
void RunCyclic() {
while (!m_StopRequested.load()) {
if (m_Algorithm) {
m_Algorithm->Process(m_Input);
}
std::unique_lock<std::timed_mutex> lock(m_WaitMutex.GetNative());
m_Condition.wait_for(lock,
std::chrono::milliseconds(m_CycleTime_ms),
[this]() { return m_StopRequested.load(); });
}
}
void RunAsync() {
while (!m_StopRequested.load()) {
std::unique_lock<std::timed_mutex> lock(m_WaitMutex.GetNative());
m_Condition.wait(lock, [this]() {
return m_StopRequested.load() || m_Triggered.load();
});
if (m_StopRequested.load()) break;
m_Triggered.store(false);
if (m_Algorithm) {
m_Algorithm->Process(m_Input);
}
}
}
AlgorithmType* m_Algorithm;
Mode m_Mode;
int m_CycleTime_ms;
T_enc m_Input;
std::atomic<bool> m_StopRequested;
std::atomic<bool> m_Triggered;
Mutex m_WaitMutex;
std::condition_variable_any m_Condition;
};
} // namespace uLib
#endif // U_CORE_ALGORITHM_H

294
src/Core/Archives.h
View File

@@ -28,8 +28,6 @@
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <cstring>
#include <iostream>
#include <boost/archive/text_iarchive.hpp>
@@ -61,8 +59,6 @@ class xml_iarchive;
class xml_oarchive;
class text_iarchive;
class text_oarchive;
class hrt_iarchive;
class hrt_oarchive;
class log_archive;
} // namespace Archive
@@ -80,9 +76,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
@@ -157,7 +150,7 @@ public:
Archive *This() { return static_cast<Archive *>(this); }
template <class T>
const basic_pointer_iserializer *register_type(T * = nullptr) {
const basic_pointer_iserializer *register_type(T * = NULL) {
const basic_pointer_iserializer &bpis = boost::serialization::singleton<
pointer_iserializer<Archive, T>>::get_const_instance();
this->This()->register_basic_serializer(bpis.get_basic_serializer());
@@ -168,69 +161,15 @@ public:
return *this->This();
}
template <class T>
Archive &operator>>(const boost::serialization::nvp<T> &t) {
this->This()->load_override(t);
return *this->This();
}
template <class T>
Archive &operator>>(const boost::serialization::hrp<T> &t) {
this->This()->load_override(const_cast<boost::serialization::hrp<T> &>(t));
return *this->This();
}
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; }
template <class T>
Archive &operator&(const boost::serialization::nvp<T> &t) {
return *(this->This()) >> t;
}
template <class T>
Archive &operator&(const boost::serialization::hrp<T> &t) {
return *(this->This()) >> t;
}
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); }
// the != operator for human readable access
template <class T> Archive &operator!=(T &t) {
std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
return *this->This();
}
};
@@ -252,7 +191,7 @@ public:
Archive *This() { return static_cast<Archive *>(this); }
template <class T>
const basic_pointer_oserializer *register_type(const T * = nullptr) {
const basic_pointer_oserializer *register_type(const T * = NULL) {
const basic_pointer_oserializer &bpos = boost::serialization::singleton<
pointer_oserializer<Archive, T>>::get_const_instance();
this->This()->register_basic_serializer(bpos.get_basic_serializer());
@@ -265,67 +204,18 @@ public:
this->This()->save_override(t);
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); }
// the != operator for human readable access
template <class T> Archive &operator!=(T &t) {
std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
return *this->This();
}
};
@@ -350,22 +240,23 @@ template <>
class interface_oarchive<uLib::Archive::text_oarchive>
: public uLib_interface_oarchive<uLib::Archive::text_oarchive> {};
template <>
class interface_iarchive<uLib::Archive::hrt_iarchive>
: public uLib_interface_iarchive<uLib::Archive::hrt_iarchive> {};
template <>
class interface_oarchive<uLib::Archive::hrt_oarchive>
: public uLib_interface_oarchive<uLib::Archive::hrt_oarchive> {};
template <>
class interface_iarchive<uLib::Archive::log_archive>
: public uLib_interface_iarchive<uLib::Archive::log_archive> {};
template <>
class interface_oarchive<uLib::Archive::log_archive>
: public uLib_interface_oarchive<uLib::Archive::log_archive> {};
//// Veritical repetition macro // FINIRE !!!!!!!!!!!!!!!!!!!!!!!!!
// #define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata) \
// template <class TypeSeq> \
// struct inherit_nofold<TypeSeq,BOOST_PP_INC(vn)> : \
// BOOST_PP_REPEAT(BOOST_PP_INC(vn),_INERIT_NOFOLD_H,~) \
// {};
//// Multiple size declaration //
// BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
// #undef _INERIT_NOFOLD_H
// #undef _INERIT_NOFOLD_V
} // namespace detail
} // namespace archive
} // namespace boost
@@ -384,6 +275,36 @@ class interface_oarchive<uLib::Archive::log_archive>
namespace boost {
namespace archive {
// template<class Archive>
// inline void load_const_override(Archive & ar, const char *t ){
// typedef typename mpl::identity<detail::load_non_pointer_type<Archive>
// >::type typex; typex::invoke(ar, t);
// }
// template<class Archive, class T>
// inline void load(Archive & ar, T &t){
// // if this assertion trips. It means we're trying to load a
// // const object with a compiler that doesn't have correct
// // funtion template ordering. On other compilers, this is
// // handled below.
// // detail::check_const_loading< T >();
// typedef
// BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
// mpl::identity<detail::load_pointer_type<Archive> >
// ,//else
// BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
// mpl::identity<detail::load_array_type<Archive> >
// ,//else
// BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
// mpl::identity<detail::load_enum_type<Archive> >
// ,//else
// mpl::identity<detail::load_non_pointer_type<Archive> >
// >
// >
// >::type typex;
// typex::invoke(ar, t);
// }
} // namespace archive
} // namespace boost
@@ -391,38 +312,42 @@ namespace uLib {
namespace Archive {
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// POLYMORPHIC //
// class polymorphic_iarchive :
// public boost::archive::polymorphic_iarchive {
// public:
// void load_override(const char *t, BOOST_PFTO int)
// {
// boost::archive::load_const_override(* this->This(),
// const_cast<char*>(t));
// }
//};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// XML //
// ULIB_SERIALIZATION_VERSION should be get from the build system
#ifndef ULIB_SERIALIZATION_VERSION
#define ULIB_SERIALIZATION_VERSION "0.0"
#endif
class xml_iarchive : public boost::archive::xml_iarchive_impl<xml_iarchive> {
typedef xml_iarchive Archive;
typedef boost::archive::xml_iarchive_impl<Archive> base;
unsigned int m_flags;
// give serialization implementation access to this class
friend class boost::archive::detail::interface_iarchive<Archive>;
friend class boost::archive::basic_xml_iarchive<Archive>;
friend class boost::archive::load_access;
public:
xml_iarchive(std::istream &is, unsigned int flags = 0)
: boost::archive::xml_iarchive_impl<xml_iarchive>(
is, flags | boost::archive::no_header), m_flags(flags) {
if (0 == (flags & boost::archive::no_header)) {
std::string line;
std::getline(is, line); // <?xml ... ?>
std::getline(is, line); // <!DOCTYPE ...>
std::getline(is, line); // <ulib_serialization ...>
}
}
: xml_iarchive_impl<xml_iarchive>(is, flags) {}
using basic_xml_iarchive::load_override;
// Anything not an attribute should be a name value pair as nvp or hrp
typedef boost::archive::detail::common_iarchive<Archive>
@@ -441,19 +366,20 @@ public:
// class_name_type can't be handled here as it depends upon the
// char type used by the stream. So require the derived implementation.
// derived in this case is xml_iarchive_impl or base ..
// Note: using base::load_override covers all basic_xml_iarchive overloads
// transitively, so a separate 'using basic_xml_iarchive::load_override'
// is redundant and creates ambiguity with clang.
using base::load_override;
void load_override(const char *str) {
// StringReader sr(basic_text_iprimitive::is);
// sr >> str;
// StringReader sr(basic_text_iprimitive::is);
// sr >> str;
}
virtual ~xml_iarchive() {}
~xml_iarchive() {};
};
// typedef boost::archive::detail::polymorphic_iarchive_route<
// boost::archive::xml_iarchive_impl<xml_iarchive>
//> polymorphic_xml_iarchive;
template <class ArchiveImpl>
struct polymorphic_iarchive_route
: boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl> {
@@ -463,39 +389,31 @@ struct polymorphic_iarchive_route
class polymorphic_xml_iarchive
: public polymorphic_iarchive_route<
boost::archive::xml_iarchive_impl<xml_iarchive>> {
// give serialization implementation access to this class
// friend class boost::archive::detail::interface_iarchive<Archive>;
// friend class boost::archive::basic_xml_iarchive<Archive>;
// friend class boost::archive::load_access;
public:
virtual void load_override(const char *str) {}
virtual void load_override(const char *str) { ; }
};
class xml_oarchive : public boost::archive::xml_oarchive_impl<xml_oarchive> {
typedef xml_oarchive Archive;
typedef boost::archive::xml_oarchive_impl<Archive> base;
unsigned int m_flags;
// give serialization implementation access to this class
friend class boost::archive::detail::interface_oarchive<Archive>;
friend class boost::archive::basic_xml_oarchive<Archive>;
friend class boost::archive::save_access;
public:
xml_oarchive(std::ostream &os, unsigned int flags = 0)
: boost::archive::xml_oarchive_impl<xml_oarchive>(
os, flags | boost::archive::no_header), m_flags(flags) {
if (0 == (flags & boost::archive::no_header)) {
this->This()->put(
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
this->This()->put("<!DOCTYPE ulib_serialization>\n");
this->This()->put("<ulib_serialization signature=\"serialization::archive\" ");
this->write_attribute("version", (const char *)ULIB_SERIALIZATION_VERSION);
this->This()->put(">\n");
}
}
: boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
virtual ~xml_oarchive() {
if (0 == (m_flags & boost::archive::no_header)) {
this->This()->put("</ulib_serialization>\n");
}
}
// example of implementing save_override for const char* //
// void save_override(const char *t, int) {
// std::cout << "found char: " << t << "\n";
// }
using basic_xml_oarchive::save_override;
@@ -515,8 +433,10 @@ public:
void save_override(const char *str) {
// Do not save any human decoration string //
// basic_text_oprimitive::save(str);
// basic_text_oprimitive::save(str);
}
~xml_oarchive() {}
};
// typedef boost::archive::detail::polymorphic_oarchive_route<
@@ -551,11 +471,15 @@ public:
sr >> str;
}
virtual ~text_iarchive() {}
~text_iarchive() {};
};
typedef text_iarchive naked_text_iarchive;
// typedef boost::archive::detail::polymorphic_iarchive_route<
// naked_text_iarchive
//> polymorphic_text_iarchive;
class text_oarchive : public boost::archive::text_oarchive_impl<text_oarchive> {
typedef text_oarchive Archive;
typedef boost::archive::text_oarchive_impl<Archive> base;
@@ -573,9 +497,13 @@ public:
void save_override(const char *str) { basic_text_oprimitive::save(str); }
virtual ~text_oarchive() {}
~text_oarchive() {}
};
// typedef boost::archive::detail::polymorphic_oarchive_route<
// boost::archive::text_oarchive_impl<text_oarchive>
//> polymorphic_text_oarchive;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -612,7 +540,7 @@ public:
sr >> str;
}
virtual ~hrt_iarchive() {}
~hrt_iarchive() {};
};
class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
@@ -648,7 +576,7 @@ public:
*this << "\n";
}
virtual ~hrt_oarchive() {}
~hrt_oarchive() {}
};
////////////////////////////////////////////////////////////////////////////////
@@ -677,9 +605,17 @@ public:
}
template <class T> void save_override(const T &t) {
base::save_override(boost::serialization::make_nvp(nullptr, t));
base::save_override(boost::serialization::make_nvp(NULL, t));
}
// activate this if you want to trap non nvp objects //
// template<class T>
// void save_override(T & t)
// {
// BOOST_MPL_ASSERT((boost::serialization::is_wrapper< T >));
// // this->detail_common_oarchive::save_override(t);
// }
template <class T> void save_override(const boost::serialization::nvp<T> &t) {
base::save_override(t);
}
@@ -704,10 +640,12 @@ public:
log_archive(std::ostream &os, unsigned int flags = 0)
: boost::archive::xml_oarchive_impl<log_archive>(
os, flags | boost::archive::no_header) {}
virtual ~log_archive() {}
};
// typedef boost::archive::detail::polymorphic_oarchive_route<
// boost::archive::xml_oarchive_impl<log_archive>
//> polymorphic_log_archive;
} // namespace Archive
} // namespace uLib
@@ -720,4 +658,10 @@ ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_iarchive)
ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_oarchive)
ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::log_archive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
#endif // U_CORE_ARCHIVES_H

9
src/Core/CMakeLists.txt
View File

@@ -1,7 +1,8 @@
set(HEADERS
Archives.h
Array.h
set(HEADERS
Algorithm.h
Archives.h
Array.h
Collection.h
DataAllocator.h
Debug.h
@@ -21,7 +22,6 @@ set(HEADERS
StringReader.h
Threads.h
Monitor.h
Property.h
Types.h
Uuid.h
Vector.h
@@ -59,7 +59,6 @@ if(USE_CUDA)
endif()
target_link_libraries(${libname} ${LIBRARIES})
target_compile_definitions(${libname} PUBLIC ULIB_SERIALIZATION_VERSION="${PROJECT_VERSION}")
install(TARGETS ${libname}
EXPORT "uLibTargets"

6
src/Core/DataAllocator.h
View File

@@ -46,8 +46,6 @@ public:
DataAllocator(size_t size = 0, bool owns_objects = true)
: m_Size(size), m_RamData(nullptr), m_VramData(nullptr),
m_Device(MemoryDevice::RAM), m_OwnsObjects(owns_objects) {
if (m_Size >= (static_cast<size_t>(1) << 60))
throw std::invalid_argument("DataAllocator: absurdly large size requested");
if (m_Size > 0) {
if (m_OwnsObjects)
m_RamData = new T[m_Size]();
@@ -141,7 +139,7 @@ public:
void MoveToRAM() {
if (m_Device == MemoryDevice::RAM)
return;
if (!m_RamData && m_Size > 0 && m_Size < (static_cast<size_t>(1) << 60)) {
if (!m_RamData && m_Size > 0) {
if (m_OwnsObjects)
m_RamData = new T[m_Size]();
else
@@ -180,7 +178,7 @@ public:
T *newRam = nullptr;
T *newVram = nullptr;
if (size > 0 && size < (static_cast<size_t>(1) << 60)) {
if (size > 0) {
if (m_OwnsObjects)
newRam = new T[size]();
else

71
src/Core/Debug.h
View File

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

58
src/Core/Object.cpp
View File

@@ -59,41 +59,18 @@ public:
GenericMFPtr sloptr;
std::string slostr;
};
~ObjectPrivate() {
for (auto& s : sigv) delete s.signal;
}
std::string m_InstanceName;
std::vector<Signal> sigv;
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) {
for (auto* existing : d->m_DisplayProperties) {
if (existing == prop) return;
if (existing->GetName() == prop->GetName()) return;
}
d->m_DisplayProperties.push_back(prop);
}
}
const std::vector<PropertyBase*>& Object::GetDisplayProperties() const {
return d->m_DisplayProperties;
}
void Object::RegisterProperty(PropertyBase* prop) {
if (prop) {
for (auto* existing : d->m_Properties) {
if (existing == prop) return;
if (existing->GetName() == prop->GetName()) return;
}
d->m_Properties.push_back(prop);
}
}
@@ -102,7 +79,6 @@ void Object::RegisterDynamicProperty(PropertyBase* prop) {
if (prop) {
for (auto* existing : d->m_DynamicProperties) {
if (existing == prop) return;
if (existing->GetQualifiedName() == prop->GetQualifiedName()) return;
}
d->m_DynamicProperties.push_back(prop);
}
@@ -119,20 +95,34 @@ PropertyBase* Object::GetProperty(const std::string& name) const {
for (auto* p : d->m_DynamicProperties) {
if (p->GetName() == name || p->GetQualifiedName() == name) return p;
}
for (auto* p : d->m_DisplayProperties) {
if (p->GetName() == name || p->GetQualifiedName() == name) return p;
}
return nullptr;
}
void Object::NotifyPropertiesUpdated() {
// Only notify properties in the primary list to avoid duplicates,
// as all registered properties should be there.
for (auto* p : d->m_Properties) 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); }
template <class ArchiveT>
void Object::save_override(ArchiveT &ar, const unsigned int version) {}
// Explicitly instantiate for all uLib archives
template void Object::serialize(Archive::xml_oarchive &, const unsigned int);
template void Object::serialize(Archive::xml_iarchive &, const unsigned int);
template void Object::serialize(Archive::text_oarchive &, const unsigned int);
template void Object::serialize(Archive::text_iarchive &, const unsigned int);
template void Object::serialize(Archive::hrt_oarchive &, const unsigned int);
template void Object::serialize(Archive::hrt_iarchive &, const unsigned int);
template void Object::serialize(Archive::log_archive &, const unsigned int);
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -164,9 +154,6 @@ Object::~Object() {
for (auto* p : d->m_DynamicProperties) {
delete p;
}
for (auto* p : d->m_DisplayProperties) {
delete p;
}
delete d;
}
@@ -208,8 +195,7 @@ void Object::PrintSelf(std::ostream &o) const {
bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
const char *name) {
if (!d) return false;
ObjectPrivate::Signal s = {fptr, std::string(name ? name : "unnamed"), sig};
ObjectPrivate::Signal s = {fptr, std::string(name), sig};
d->sigv.push_back(s);
return true;
}

70
src/Core/Object.h
View File

@@ -52,7 +52,6 @@ class polymorphic_oarchive;
namespace uLib {
class PropertyBase;
class ObjectsContext;
class Version {
public:
@@ -78,31 +77,23 @@ public:
Object(const Object &copy);
virtual ~Object();
virtual const char *GetClassName() const { return type_name(); }
virtual const char *type_name() const { return "Object"; }
virtual const char * GetClassName() const { return "Object"; }
const std::string &GetInstanceName() const;
void SetInstanceName(const std::string &name);
/** @brief Temporarily blocks all signal emissions from this object. Returns
* previous state. */
const std::string& GetInstanceName() const;
void SetInstanceName(const std::string& name);
/** @brief Temporarily blocks all signal emissions from this object. Returns previous state. */
bool blockSignals(bool block);
/** @brief Checks if signals are currently blocked. */
bool signalsBlocked() const;
////////////////////////////////////////////////////////////////////////////
// PROPERTIES //
virtual void RegisterProperty(PropertyBase *property);
virtual void RegisterDynamicProperty(PropertyBase *property);
virtual void RegisterDisplayProperty(PropertyBase *property);
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. */
void NotifyPropertiesUpdated();
void RegisterProperty(PropertyBase* prop);
void RegisterDynamicProperty(PropertyBase* prop);
const std::vector<PropertyBase*>& GetProperties() const;
PropertyBase* GetProperty(const std::string& name) const;
////////////////////////////////////////////////////////////////////////////
// PARAMETERS //
@@ -110,32 +101,22 @@ public:
// FIXX !!!
virtual void DeepCopy(const Object &copy);
/** @brief Returns a nested context for children objects, if any. */
virtual ObjectsContext *GetChildren() { return nullptr; }
////////////////////////////////////////////////////////////////////////////
// SERIALIZATION //
template <class ArchiveT>
void serialize(ArchiveT &ar, const unsigned int version);
virtual void serialize(Archive::xml_oarchive &ar,
const unsigned int version) {}
virtual void serialize(Archive::xml_iarchive &ar,
const unsigned int version) {}
virtual void serialize(Archive::text_oarchive &ar,
const unsigned int version) {}
virtual void serialize(Archive::text_iarchive &ar,
const unsigned int version) {}
virtual void serialize(Archive::hrt_oarchive &ar,
const unsigned int version) {}
virtual void serialize(Archive::hrt_iarchive &ar,
const unsigned int version) {}
virtual void serialize(Archive::log_archive &ar, const unsigned int version) {
}
virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) {}
virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) {}
virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) {}
virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) {}
virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) {}
virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) {}
virtual void serialize(Archive::log_archive & ar, const unsigned int version) {}
template <class ArchiveT>
void save_override(ArchiveT &ar, const unsigned int version) {}
void save_override(ArchiveT &ar, const unsigned int version);
void SaveConfig(std::ostream &os, int version = 0);
void LoadConfig(std::istream &is, int version = 0);
@@ -146,7 +127,7 @@ public:
////////////////////////////////////////////////////////////////////////////
// SIGNALS //
signals:
signals:
virtual void Updated();
// Qt4 style connector //
@@ -168,14 +149,14 @@ signals:
connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
SignalBase *sigb = sender->findOrAddSignal(sigf);
return ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(
sigb, slof, receiver);
return ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(sigb, slof,
receiver);
}
// Lambda/Function object connector //
template <typename Func1, typename SlotT>
static Connection connect(typename FunctionPointer<Func1>::Object *sender,
Func1 sigf, SlotT slof) {
Func1 sigf, SlotT slof) {
SignalBase *sigb = sender->findOrAddSignal(sigf);
typedef typename FunctionPointer<Func1>::SignalSignature SigSignature;
typedef typename Signal<SigSignature>::type SigT;
@@ -191,10 +172,9 @@ signals:
}
template <typename FuncT>
static inline Connection connect(SignalBase *sigb, FuncT slof,
Object *receiver) {
return ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(
sigb, slof, receiver);
static inline Connection connect(SignalBase *sigb, FuncT slof, Object *receiver) {
return ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(sigb, slof,
receiver);
}
template <typename FuncT>

110
src/Core/ObjectFactory.h
View File

@@ -1,55 +1,53 @@
#ifndef U_CORE_OBJECTFACTORY_H
#define U_CORE_OBJECTFACTORY_H
#include "Core/Object.h"
#include <functional>
#include <map>
#include <string>
#include <type_traits>
#include <map>
#include <vector>
#include <functional>
#include "Core/Object.h"
namespace uLib {
/**
* @brief Singleton factory for dynamic Object instantiation based on class
* name.
* @brief Singleton factory for dynamic Object instantiation based on class name.
*/
class ObjectFactory {
public:
typedef std::function<Object *()> FactoryFunction;
typedef std::function<Object*()> FactoryFunction;
/** @brief Get the singleton instance. */
static ObjectFactory &Instance();
/** @brief Get the singleton instance. */
static ObjectFactory& Instance();
/** @brief Register a factory function for a given class name. */
void Register(const std::string &className, FactoryFunction func);
/** @brief Register a factory function for a given class name. */
void Register(const std::string& className, FactoryFunction func);
/** @brief Create a new instance of the specified class. */
Object *Create(const std::string &className);
/** @brief Create a new instance of the specified class. */
Object* Create(const std::string& className);
/** @brief Get the names of all registered classes. */
std::vector<std::string> GetRegisteredClasses() const;
/** @brief Get the names of all registered classes. */
std::vector<std::string> GetRegisteredClasses() const;
private:
ObjectFactory() = default;
~ObjectFactory() = default;
ObjectFactory() = default;
~ObjectFactory() = default;
// Prevent copy and assignment
ObjectFactory(const ObjectFactory &) = delete;
ObjectFactory &operator=(const ObjectFactory &) = delete;
// Prevent copy and assignment
ObjectFactory(const ObjectFactory&) = delete;
ObjectFactory& operator=(const ObjectFactory&) = delete;
std::map<std::string, FactoryFunction> m_factoryMap;
std::map<std::string, FactoryFunction> m_factoryMap;
};
/**
* @brief Helper class to statically register a factory function.
*/
template <typename T> class ObjectRegistrar {
template <typename T>
class ObjectRegistrar {
public:
ObjectRegistrar(const std::string &className) {
ObjectFactory::Instance().Register(className,
[]() -> Object * { return new T(); });
}
ObjectRegistrar(const std::string& className) {
ObjectFactory::Instance().Register(className, []() -> Object* { return new T(); });
}
};
#define ULIB_REG_CONCAT_IMPL(a, b) a##b
@@ -59,63 +57,11 @@ public:
* @brief Macro to register a class to the factory.
* Put this in the .cpp file of the class.
*/
#define ULIB_REGISTER_OBJECT(className) \
static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT( \
g_ObjectRegistrar_, __LINE__)(#className);
#define ULIB_REGISTER_OBJECT(className) \
static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(g_ObjectRegistrar_, __LINE__)(#className);
#define ULIB_REGISTER_OBJECT_NAME(className, registeredName) \
static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT( \
g_ObjectRegistrar_, __LINE__)(registeredName);
template <typename T> class ObjectWrapper {
public:
ObjectWrapper(const std::string &className) {
ObjectFactory::Instance().Register(className,
[]() -> Object * { return new T(); });
}
ObjectWrapper(T *model) : m_model(model) {}
template <typename U = T,
typename = std::enable_if_t<std::is_default_constructible_v<U>>>
ObjectWrapper() : m_model(new T()) {}
ObjectWrapper(const ObjectWrapper &other) : m_model(other.m_model) {}
ObjectWrapper &operator=(const ObjectWrapper &other) {
m_model = other.m_model;
return *this;
}
ObjectWrapper(ObjectWrapper &&other) noexcept
: m_model(std::move(other.m_model)) {}
ObjectWrapper &operator=(ObjectWrapper &&other) noexcept {
m_model = std::move(other.m_model);
return *this;
}
~ObjectWrapper() = default;
T *operator->() const { return m_model.get(); }
T &operator*() const { return *m_model; }
T *get() const { return m_model.get(); }
bool operator==(const ObjectWrapper &other) const {
return m_model == other.m_model;
}
bool operator!=(const ObjectWrapper &other) const {
return m_model != other.m_model;
}
explicit operator bool() const { return m_model != nullptr; }
protected:
SmartPointer<T> m_model;
};
#define ULIB_REGISTER_OBJECT_NAME(className, registeredName) \
static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(g_ObjectRegistrar_, __LINE__)(registeredName);
} // namespace uLib

4
src/Core/ObjectsContext.cpp
View File

@@ -8,9 +8,7 @@ ObjectsContext::ObjectsContext() : Object() {}
ObjectsContext::~ObjectsContext() {}
void ObjectsContext::AddObject(Object* obj) {
if (!obj || obj == this) return;
if (std::find(m_objects.begin(), m_objects.end(), obj) == m_objects.end()) {
if (obj && std::find(m_objects.begin(), m_objects.end(), obj) == m_objects.end()) {
m_objects.push_back(obj);
// Connect child's update to context's update to trigger re-renders
Object::connect(obj, &Object::Updated, this, &Object::Updated);

5
src/Core/ObjectsContext.h
View File

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

372
src/Core/Property.h
View File

@@ -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/type_traits/is_base_of.hpp>
#include <boost/serialization/serialization.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 {
@@ -40,30 +36,23 @@ public:
}
virtual const std::string& GetGroup() const = 0;
virtual void SetGroup(const std::string& group) = 0;
virtual bool HasRange() const { return false; }
virtual double GetMin() const { return 0; }
virtual double GetMax() const { return 0; }
virtual bool HasDefault() const { return false; }
virtual std::string GetDefaultValueAsString() const { return ""; }
virtual bool IsReadOnly() const = 0;
std::string GetQualifiedName() const {
if (GetGroup().empty()) return GetName();
return GetGroup() + "." + GetName();
}
// Signal support
signals:
virtual void Updated() override { ULIB_SIGNAL_EMIT(PropertyBase::Updated); }
// Serialization support for different uLib archives
virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) override = 0;
virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) override = 0;
virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) override = 0;
virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) override = 0;
virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) override = 0;
virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) override = 0;
virtual void serialize(Archive::log_archive & ar, const unsigned int version) override = 0;
virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) = 0;
virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) = 0;
virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) = 0;
virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) = 0;
virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) = 0;
virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) = 0;
virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) = 0;
virtual void serialize(Archive::log_archive & ar, const unsigned int version) = 0;
};
/**
@@ -72,19 +61,25 @@ public:
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);
: m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(valuePtr), m_own(false) {
if (m_owner) {
m_owner->RegisterProperty(this);
}
}
// 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);
: m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(new T(defaultValue)), m_own(true) {
if (m_owner) {
m_owner->RegisterProperty(this);
}
}
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; }
@@ -95,96 +90,76 @@ 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); }
catch (...) { std::stringstream ss; ss << *m_value; return ss.str(); }
try {
return boost::lexical_cast<std::string>(*m_value);
} catch (const boost::bad_lexical_cast&) {
std::stringstream ss;
ss << *m_value;
return ss.str();
}
}
// Accessors
const T& Get() const { return *m_value; }
void Set(const T& value) {
if (!m_value) return;
T val = value;
if constexpr (std::is_arithmetic<T>::value) {
if (m_HasRange) { if (val < m_Min) val = m_Min; if (val > m_Max) val = m_Max; }
}
if (*m_value != val) {
*m_value = val;
if (*m_value != value) {
*m_value = value;
ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
this->Updated();
if (m_owner) m_owner->Updated();
}
}
void SetRange(const T& min, const T& max) { m_Min = min; m_Max = max; m_HasRange = true; }
void SetDefault(const T& def) { m_Default = def; m_HasDefault = true; }
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; }
const T& GetMaxTyped() const { return m_Max; }
virtual bool HasDefault() const override { return m_HasDefault; }
virtual std::string GetDefaultValueAsString() const override {
try { return boost::lexical_cast<std::string>(m_Default); } catch (...) { return ""; }
// Operators for seamless usage
operator const T&() const { return *m_value; }
Property& operator=(const T& value) {
Set(value);
return *this;
}
// Operators
operator const T&() const { return *m_value; }
Property& operator=(const T& value) { Set(value); return *this; }
// Signals
signals:
virtual void PropertyChanged() { ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged); }
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) {
ar & boost::serialization::make_hrp(m_name.c_str(), *m_value, m_units.c_str());
void serialize_impl(ArchiveT & ar, const unsigned int version) {
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); }
virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
virtual void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_helper(ar, v); }
virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override;
void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_impl(ar, v); }
protected:
private:
std::string m_name;
std::string m_units;
std::string m_group;
T* m_value;
bool m_own;
Object* m_owner;
bool m_HasRange;
T m_Min;
T m_Max;
bool m_HasDefault;
T m_Default;
bool m_ReadOnly;
};
/**
* @brief 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:
@@ -195,49 +170,58 @@ 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
: public boost::archive::detail::common_oarchive<property_register_archive> {
protected:
namespace boost {
namespace archive {
namespace detail {
template <>
class interface_oarchive<uLib::Archive::property_register_archive>
: public uLib_interface_oarchive<uLib::Archive::property_register_archive> {};
} // namespace detail
} // namespace archive
} // namespace boost
namespace uLib {
namespace Archive {
/**
* @brief A special archive that creates and registers Property proxies
* for any member it encounters wrapped in HRP().
*/
class property_register_archive :
public boost::archive::detail::common_oarchive<property_register_archive>
{
Object* m_Object;
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) {
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; }
m_Object(obj) {}
std::string GetCurrentGroup() const {
std::string group;
@@ -248,91 +232,46 @@ public:
return group;
}
template<class T> void register_property(Property<T>& p) {
save_property_impl(p.GetName().c_str(), const_cast<T&>(p.Get()), p.GetUnits().c_str(),
p.HasRange(), p.GetMinTyped(), p.GetMaxTyped(), p.IsReadOnly());
}
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, &Object::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) {
// Core logic: encounter HRP -> Create Dynamic Property
template<class T>
void save_override(const boost::serialization::hrp<T> &t) {
if (m_Object) {
Property<T>* p = new Property<T>(m_Object, name, &val, units ? units : "", GetCurrentGroup());
set_range_helper(p, hasRange, minVal, maxVal, typename std::is_arithmetic<T>::type());
p->SetReadOnly(isReadOnly);
if (m_DisplayOnly) {
m_Object->RegisterDisplayProperty(p);
Object* obj = m_Object;
Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); });
} else {
m_Object->RegisterDynamicProperty(p);
}
Property<T>* p = new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp<T>&>(t).value(), t.units() ? t.units() : "", GetCurrentGroup());
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 U> static void set_range_helper(Property<U>* p, bool hasRange, const U& minVal, const U& maxVal, std::false_type) {}
template<class T> void save_override(const boost::serialization::hrp<T> &t) {
// To handle T correctly without deduction issues, we assume T can be passed to save_property_impl
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) {
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, &Object::Updated, [obj]() { obj->Updated(); }); }
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, &Object::Updated, [obj]() { obj->Updated(); }); }
else { m_Object->RegisterDynamicProperty(p); }
m_Object->RegisterDynamicProperty(p);
}
}
template<class T> void save_override(const boost::serialization::nvp<T> &t) {
// 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) {}
template<class T> void save_override(T * const & t) {
if (!t) return;
this->save_pointer_helper(t, typename boost::is_base_of<Object, T>::type());
// Recursion for nested classes, ignore primitives
template<class T>
void save_override(const T &t) {
this->save_helper(t, typename boost::is_class<T>::type());
}
template<class T> void save_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) {}
@@ -342,65 +281,18 @@ 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); }
#define ULIB_DECLARE_PROPERTIES(SelfType) \
private: \
struct _PropActivator { \
_PropActivator(SelfType* self) { \
uLib::Archive::property_register_archive _ar(self); \
_ar & *self; \
} \
} _prop_activator{this};
{ uLib::Archive::property_register_archive _ar_tmp(&(obj)); (obj).serialize(_ar_tmp, 0); }
} // 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

264
src/Core/Serializable.h
View File

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

2
src/Core/Signal.h
View File

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

260
src/Core/SmartPointer.h
View File

@@ -23,249 +23,89 @@
//////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_SMARTPOINTER_H
#define U_CORE_SMARTPOINTER_H
#include <atomic>
#include <functional>
#include <type_traits>
#include <utility>
namespace uLib {
/**
* @brief A smart pointer implementation inspired by std::shared_ptr.
*
* Features modernized C++11/14/17 syntax, thread-safe reference counting,
* move semantics, and support for custom deleters.
*
* NOTE: Default constructor allocates a new T following legacy behavior.
*/
template <typename T>
class SmartPointer {
typedef T element_type;
public:
using element_type = T;
/**
* @brief Constructor from raw pointer.
* If ptr is nullptr, a new T is allocated (legacy behavior).
*/
explicit SmartPointer(T* ptr = nullptr) : m_counter(nullptr) {
if (!ptr) {
if constexpr (std::is_default_constructible_v<T>) {
ptr = new T();
}
}
explicit
SmartPointer(T* ptr = NULL) : m_counter(0) {
if(!ptr) ptr = new T;
if (ptr) m_counter = new ReferenceCounter(ptr);
}
/**
* @brief Constructor with custom deleter.
*/
template <typename D>
SmartPointer(T* ptr, D deleter) : m_counter(nullptr) {
if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
// TakeReference //
SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref,0)) { }
SmartPointer(const SmartPointer& copy) throw () {
acquire(copy.m_counter);
}
/**
* @brief Non-owning constructor from reference.
* Uses a no-op deleter to ensure the referenced object is not destroyed.
*/
SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){}, 1)) { }
/**
* @brief Copy constructor.
*/
SmartPointer(const SmartPointer& other) noexcept : m_counter(nullptr) {
acquire(other.m_counter);
SmartPointer(SmartPointer * copy) throw () {
acquire(copy->m_counter);
}
/**
* @brief Copy constructor from a pointer to SmartPointer (Legacy support).
*/
SmartPointer(const SmartPointer* other) noexcept : m_counter(nullptr) {
if (other) acquire(other->m_counter);
}
virtual ~SmartPointer() { release(); }
/**
* @brief Move constructor.
*/
SmartPointer(SmartPointer&& other) noexcept : m_counter(other.m_counter) {
other.m_counter = nullptr;
}
/**
* @brief Virtual destructor.
*/
virtual ~SmartPointer() { release(); }
/**
* @brief Copy assignment.
*/
SmartPointer& operator=(const SmartPointer& other) noexcept {
if (this != &other) {
SmartPointer & operator=(const SmartPointer& copy) {
if (this != &copy)
{
release();
acquire(other.m_counter);
acquire(copy.m_counter);
}
return *this;
}
/**
* @brief Move assignment.
*/
SmartPointer& operator=(SmartPointer&& other) noexcept {
if (this != &other) {
release();
m_counter = other.m_counter;
other.m_counter = nullptr;
}
return *this;
}
T & operator*() const throw () { return *m_counter->ptr; }
T * operator->() const throw () { return m_counter->ptr; }
/**
* @brief Resets the smart pointer to hold a new raw pointer.
*/
void reset(T* ptr = nullptr) {
release();
if (ptr) m_counter = new ReferenceCounter(ptr);
}
T * get() const throw () {
return m_counter ? m_counter->ptr : 0; }
bool unique() const throw () {
return (m_counter ? m_counter->count == 1 : true); }
/**
* @brief Resets the smart pointer with a custom deleter.
*/
template <typename D>
void reset(T* ptr, D deleter) {
release();
if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
}
/**
* @brief Swaps contents with another SmartPointer.
*/
void swap(SmartPointer& other) noexcept {
std::swap(m_counter, other.m_counter);
}
private:
/**
* @brief Dereference operator.
*/
T& operator*() const noexcept { return *m_counter->ptr; }
struct ReferenceCounter
{
ReferenceCounter(T* ptr = 0, unsigned c = 1) : ptr(ptr), count(c) { }
T* ptr;
unsigned count;
} * m_counter;
/**
* @brief Member access operator.
*/
T* operator->() const noexcept { return m_counter->ptr; }
/**
* @brief Returns the raw pointer.
*/
T* get() const noexcept { return m_counter ? m_counter->ptr : nullptr; }
/**
* @brief Implicit conversion to raw pointer (legacy compatibility).
*/
operator T*() const noexcept { return get(); }
/**
* @brief Returns the number of SmartPointers sharing ownership.
*/
uint32_t use_count() const noexcept {
return m_counter ? m_counter->count.load(std::memory_order_relaxed) : 0;
}
/**
* @brief Returns true if this is the only SmartPointer owning the resource.
*/
bool unique() const noexcept { return use_count() == 1; }
/**
* @brief Boolean conversion operator.
*/
explicit operator bool() const noexcept { return get() != nullptr; }
private:
struct ReferenceCounter {
T* ptr;
std::atomic<uint32_t> count;
std::function<void(T*)> deleter;
ReferenceCounter(T* p, uint32_t initial_count = 1)
: ptr(p), count(initial_count), deleter([](T* ptr_to_del) { delete ptr_to_del; }) {}
template <typename D>
ReferenceCounter(T* p, D d, uint32_t initial_count = 1)
: ptr(p), count(initial_count), deleter(d) {}
};
ReferenceCounter* m_counter;
void acquire(ReferenceCounter* c) noexcept {
// increment the count
void acquire(ReferenceCounter* c) throw ()
{
m_counter = c;
if (c) {
c->count.fetch_add(1, std::memory_order_relaxed);
if (c && c->count>0) ++c->count;
}
// decrement the count, delete if it is 0
void release() {
if (m_counter) {
if (--m_counter->count == 0) {
delete m_counter->ptr;
}
if (m_counter->count <= 0) {
delete m_counter;
m_counter = NULL;
}
}
}
void release() noexcept {
if (m_counter) {
if (m_counter->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
if (m_counter->ptr) {
m_counter->deleter(m_counter->ptr);
}
delete m_counter;
}
m_counter = nullptr;
}
}
};
/**
* @brief Global swap for SmartPointer.
*/
template <typename T>
void swap(SmartPointer<T>& a, SmartPointer<T>& b) noexcept {
a.swap(b);
}
/**
* @brief Equality comparison.
*/
template <typename T, typename U>
bool operator==(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
return a.get() == b.get();
}
/**
* @brief Inequality comparison.
*/
template <typename T, typename U>
bool operator!=(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
return a.get() != b.get();
}
/**
* @brief Comparison with nullptr.
*/
template <typename T>
bool operator==(const SmartPointer<T>& a, std::nullptr_t) noexcept {
return a.get() == nullptr;
}
template <typename T>
bool operator==(std::nullptr_t, const SmartPointer<T>& a) noexcept {
return a.get() == nullptr;
}
template <typename T>
bool operator!=(const SmartPointer<T>& a, std::nullptr_t) noexcept {
return a.get() != nullptr;
}
template <typename T>
bool operator!=(std::nullptr_t, const SmartPointer<T>& a) noexcept {
return a.get() != nullptr;
}
} // namespace uLib
#endif // U_CORE_SMARTPOINTER_H
#endif // SMARTPOINTER_H

3
src/Core/Types.h
View File

@@ -139,6 +139,7 @@ typedef id_t Id_t;
typedef void *Pointer_t;
typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
//--- bit manipulation ---------------------------------------------------------
#ifndef BIT
#define BIT(n) (1ULL << (n))
@@ -181,7 +182,7 @@ typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
\
public: \
typedef type_info::BaseClass BaseClass; \
virtual const char *type_name() const override { return type_info::name; } \
virtual const char *type_name() const { return type_info::name; } \
/**/
/**

206
src/Core/testing/AlgorithmTest.cpp Normal file
View File

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

4
src/Core/testing/CMakeLists.txt
View File

@@ -2,8 +2,6 @@
# TESTS
set( TESTS
SmartVectorTest
SmartPointerTest
ObjectWrapperTest
VectorTest
ObjectFlagsTest
ObjectParametersTest
@@ -31,7 +29,7 @@ set( TESTS
OpenMPTest
TeamTest
AffinityTest
ReadOnlyPropertyTest
AlgorithmTest
)
set(LIBRARIES

28
src/Core/testing/ObjectWrapperTest.cpp
View File

@@ -1,28 +0,0 @@
#include "Core/ObjectFactory.h"
#include <iostream>
struct NonDefault {
NonDefault(int) {}
};
struct Default {
Default() : value(42) {}
int value;
};
int main() {
std::cout << "Testing ObjectWrapper with Default Constructible type..." << std::endl;
uLib::ObjectWrapper<Default> w1;
std::cout << "Testing ObjectWrapper with Non-Default Constructible type..." << std::endl;
NonDefault nd(10);
uLib::ObjectWrapper<NonDefault> w2(&nd);
// The following would NOT compile without SFINAE:
// uLib::ObjectWrapper<NonDefault> w3;
std::cout << "Tests passed (compilation and manual instantiation)!" << std::endl;
return 0;
}

172
src/Core/testing/PropertiesTest.cpp
View File

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

3
src/Core/testing/PropertySystemTest.cpp
View File

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

3
src/Core/testing/PropertyTypesTest.cpp
View File

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

82
src/Core/testing/ReadOnlyPropertyTest.cpp
View File

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

37
src/Core/testing/SerializeDreadDiamondTest.cpp
View File

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

9
src/Core/testing/SerializeTest.cpp
View File

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

2
src/Core/testing/VectorTest.cpp
View File

@@ -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)) {

2
src/Core/testing/testing-prototype.h
View File

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

8
src/HEP/Detectors/DetectorChamber.h
View File

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

2
src/HEP/Geant/CMakeLists.txt
View File

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

2
src/HEP/Geant/EmitterPrimary.cpp
View File

@@ -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
}

22
src/HEP/Geant/EmitterPrimary.hh
View File

@@ -23,16 +23,17 @@ class G4Event;
namespace uLib {
namespace Geant {
class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransform
class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public Object, public AffineTransform
{
public:
uLibTypeMacro(EmitterPrimary, Object)
virtual const char* GetClassName() const override { return "Geant.EmitterPrimary"; }
EmitterPrimary();
virtual ~EmitterPrimary();
// 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); }
@@ -46,12 +47,13 @@ class EmitterPrimary : public G4VUserPrimaryGeneratorAction, public AffineTransf
class SkyPlaneEmitterPrimary : public EmitterPrimary
{
public:
uLibTypeMacro(SkyPlaneEmitterPrimary, EmitterPrimary)
virtual const char* GetClassName() const override { return "Geant.SkyPlaneEmitterPrimary"; }
SkyPlaneEmitterPrimary();
virtual ~SkyPlaneEmitterPrimary();
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);
@@ -67,12 +69,13 @@ class SkyPlaneEmitterPrimary : public EmitterPrimary
class CylinderEmitterPrimary : public EmitterPrimary
{
public:
uLibTypeMacro(CylinderEmitterPrimary, EmitterPrimary)
virtual const char* GetClassName() const override { return "Geant.CylinderEmitterPrimary"; }
CylinderEmitterPrimary();
virtual ~CylinderEmitterPrimary();
virtual void GeneratePrimaries(G4Event*) override;
virtual void GeneratePrimaries(G4Event*);
void SetRadius(float r);
float GetRadius() const { return m_Radius; }
@@ -95,13 +98,14 @@ class CylinderEmitterPrimary : public EmitterPrimary
class QuadMeshEmitterPrimary : public EmitterPrimary
{
public:
uLibTypeMacro(QuadMeshEmitterPrimary, EmitterPrimary)
virtual const char* GetClassName() const override { return "Geant.QuadMeshEmitterPrimary"; }
QuadMeshEmitterPrimary();
virtual ~QuadMeshEmitterPrimary();
// Metodo principale chiamato all'inizio di ogni evento
virtual void GeneratePrimaries(G4Event*) override;
virtual void GeneratePrimaries(G4Event*);
void SetMesh(uLib::QuadMesh* mesh);

3
src/HEP/Geant/GeantEvent.h
View File

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

22
src/HEP/Geant/GeantRegistration.cpp
View File

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

21
src/HEP/Geant/Matter.cpp
View File

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

44
src/HEP/Geant/Matter.h
View File

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

3
src/HEP/Geant/Scene.h
View File

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

28
src/HEP/Geant/Solid.cpp
View File

@@ -85,7 +85,7 @@ void Solid::SetMaterial(G4Material *material) {
}
void Solid::SetTransform(Matrix4f transform) {
uLib::AffineTransform t;
uLib::AffineTransform t;
t.SetMatrix(transform);
// 2. Extract position and rotation for Geant4
@@ -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) {
@@ -148,9 +146,6 @@ void Solid::SetParent(Solid *parent) {
TessellatedSolid::TessellatedSolid()
: BaseClass("unnamed_tessellated"), m_Solid(new G4TessellatedSolid("unnamed_tessellated")) {}
TessellatedSolid::TessellatedSolid(const char *name)
: BaseClass(name), m_Solid(new G4TessellatedSolid(name)) {
}
@@ -178,15 +173,9 @@ void TessellatedSolid::Update() {
BoxSolid::BoxSolid(const char *name) :
BaseClass(name),
m_ContainerBox(new ContainerBox()),
m_Solid(new G4Box(name, 1, 1, 1))
{}
BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
m_Solid = new G4Box(name, 1, 1, 1);
m_ContainerBox = box;
m_Solid = new G4Box(name, 1,1,1);
m_Object = box;
Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
if (m_Logical) {
m_Logical->SetSolid(m_Solid);
@@ -195,16 +184,16 @@ BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
}
void BoxSolid::Update() {
if (m_ContainerBox) {
Vector3f size = m_ContainerBox->GetSize();
if (m_Object) {
Vector3f size = m_Object->GetSize();
m_Solid->SetXHalfLength(size(0) * 0.5);
m_Solid->SetYHalfLength(size(1) * 0.5);
m_Solid->SetZHalfLength(size(2) * 0.5);
// Geant4 placement is relative to center. uLib Box is anchored at corner.
// 1. Get position and rotation (clean, without scale)
Vector3f pos = m_ContainerBox->GetPosition();
Matrix3f rot = m_ContainerBox->GetRotation();
Vector3f pos = m_Object->GetPosition();
Matrix3f rot = m_Object->GetRotation();
// 2. Center = Corner + Rotation * (Half-Size)
// We must rotate the offset vector because uLib box can be rotated.
@@ -216,9 +205,6 @@ void BoxSolid::Update() {
this->SetTransform(t.GetMatrix());
}
}

36
src/HEP/Geant/Solid.h
View File

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

29
src/Math/Assembly.cpp
View File

@@ -21,35 +21,27 @@ namespace uLib {
Assembly::Assembly()
: ObjectsContext(),
TRS(),
AffineTransform(),
m_BBoxMin(Vector3f::Zero()),
m_BBoxMax(Vector3f::Zero()),
m_ShowBoundingBox(false),
m_GroupSelection(true) {
}
m_GroupSelection(true) {}
Assembly::Assembly(const Assembly &copy)
: ObjectsContext(copy),
TRS(copy),
AffineTransform(copy),
m_BBoxMin(copy.m_BBoxMin),
m_BBoxMax(copy.m_BBoxMax),
m_ShowBoundingBox(copy.m_ShowBoundingBox),
m_GroupSelection(copy.m_GroupSelection) {}
Assembly::~Assembly() {
}
Assembly::~Assembly() {}
void Assembly::AddObject(Object *obj) {
if (!obj || obj == this) return;
if (auto *at = dynamic_cast<AffineTransform *>(obj)) {
at->SetParent(this);
}
// Base class already handles the list and child->parent update connection
ObjectsContext::AddObject(obj);
this->ComputeBoundingBox();
}
void Assembly::RemoveObject(Object *obj) {
@@ -57,9 +49,7 @@ void Assembly::RemoveObject(Object *obj) {
if (at->GetParent() == this)
at->SetParent(nullptr);
}
ObjectsContext::RemoveObject(obj);
this->ComputeBoundingBox();
}
void Assembly::ComputeBoundingBox() {
@@ -74,11 +64,12 @@ void Assembly::ComputeBoundingBox() {
m_BBoxMin = Vector3f(inf, inf, inf);
m_BBoxMax = Vector3f(-inf, -inf, -inf);
Matrix4f invAsm = this->GetWorldMatrix().inverse();
for (Object *obj : objects) {
if (auto *box = dynamic_cast<ContainerBox *>(obj)) {
// ContainerBox: wm is matrix from unit cube [0,1] to local space
// Since it is parented to 'this', GetMatrix() is sufficient.
Matrix4f m = box->GetMatrix();
// ContainerBox: wm is matrix from unit cube [0,1] to assembly base
Matrix4f m = invAsm * box->GetWorldMatrix();
for (int i = 0; i < 8; ++i) {
float x = (i & 1) ? 1.0f : 0.0f;
float y = (i & 2) ? 1.0f : 0.0f;
@@ -91,7 +82,7 @@ void Assembly::ComputeBoundingBox() {
}
} else if (auto *cyl = dynamic_cast<Cylinder *>(obj)) {
// Cylinder: centered [-1, 1] radial, [-0.5, 0.5] height
Matrix4f m = cyl->GetMatrix();
Matrix4f m = invAsm * cyl->GetWorldMatrix();
for (int i = 0; i < 8; ++i) {
float x = (i & 1) ? 1.0f : -1.0f;
float y = (i & 2) ? 0.5f : -0.5f;
@@ -107,7 +98,7 @@ void Assembly::ComputeBoundingBox() {
subAsm->ComputeBoundingBox();
Vector3f subMin, subMax;
subAsm->GetBoundingBox(subMin, subMax);
Matrix4f m = subAsm->GetMatrix();
Matrix4f m = invAsm * subAsm->GetWorldMatrix();
for (int i = 0; i < 8; ++i) {
float x = (i & 1) ? subMax(0) : subMin(0);
float y = (i & 2) ? subMax(1) : subMin(1);

26
src/Math/Assembly.h
View File

@@ -31,7 +31,6 @@
#include "Math/Transform.h"
namespace uLib {
namespace Vtk { class Assembly; }
/**
* @brief Assembly groups geometric objects (ContainerBox, Cylinder, etc.)
@@ -42,24 +41,16 @@ namespace Vtk { class Assembly; }
* 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 {
class Assembly : public ObjectsContext, public AffineTransform {
public:
uLibTypeMacro(Assembly, ObjectsContext, TRS)
friend class Vtk::Assembly;
virtual const char *GetClassName() const override { return "Assembly"; }
Assembly();
Assembly(const Assembly &copy);
virtual ~Assembly();
template <class ArchiveT>
void serialize(ArchiveT & ar, const unsigned int version) {
ar & boost::serialization::make_nvp("TRS", boost::serialization::base_object<TRS>(*this));
ar & boost::serialization::make_hrp("GroupSelection", m_GroupSelection);
}
virtual void AddObject(Object* obj) override;
virtual void RemoveObject(Object* obj) override;
@@ -83,7 +74,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;
@@ -98,13 +89,10 @@ public:
signals:
virtual void Updated() override {
if (m_InUpdated) return;
if (m_InUpdated) return; // break signal recursion
m_InUpdated = true;
// Synchronize TRS part
this->TRS::Updated();
this->ComputeBoundingBox();
ULIB_SIGNAL_EMIT(Assembly::Updated);
m_InUpdated = false;
}
@@ -114,8 +102,6 @@ private:
bool m_ShowBoundingBox;
bool m_GroupSelection;
bool m_InUpdated = false;
ULIB_DECLARE_PROPERTIES(Assembly)
};
} // namespace uLib

89
src/Math/ContainerBox.h
View File

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

72
src/Math/Cylinder.h
View File

@@ -39,43 +39,37 @@ namespace uLib {
* The cylinder orientation is defined by the Axis property (0=X, 1=Y, 2=Z).
* By default, it is aligned with the Y axis (Axis=1).
*/
class Cylinder : public TRS {
uLibTypeMacro(Cylinder, TRS)
ULIB_DECLARE_PROPERTIES(Cylinder)
class Cylinder : public AffineTransform, public Object {
public:
uLibTypeMacro(Cylinder, Object)
/**
* @brief PROPERTIES
*/
float Radius;
float Height;
int Axis;
virtual const char * GetClassName() const override { return "Cylinder"; }
/**
* @brief Default constructor. Aligns with Y by default.
*/
Cylinder() : m_LocalT(this), Radius(1.0), Height(1.0), Axis(1) {
this->Sync();
ULIB_ACTIVATE_PROPERTIES(*this);
UpdateLocalMatrix();
}
/**
* @brief Constructor with radius and height.
*/
Cylinder(float radius, float height, int axis = 1)
Cylinder(float radius, float height, int axis = 1)
: m_LocalT(this), Radius(radius), Height(height), Axis(axis) {
this->Sync();
ULIB_ACTIVATE_PROPERTIES(*this);
UpdateLocalMatrix();
}
/**
* @brief Copy constructor.
*/
Cylinder(const Cylinder &copy)
: m_LocalT(this), TRS(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
this->Sync();
: m_LocalT(this), AffineTransform(copy), Radius(copy.Radius), Height(copy.Height), Axis(copy.Axis) {
ULIB_ACTIVATE_PROPERTIES(*this);
this->UpdateLocalMatrix();
}
/**
@@ -85,14 +79,13 @@ public:
void serialize(ArchiveT & ar, const unsigned int version) {
ar & HRP(Radius);
ar & HRP(Height);
ar & boost::serialization::make_hrp_enum("Axis", Axis, {"X", "Y", "Z"});
ar & NVP("TRS", boost::serialization::base_object<TRS>(*this));
ar & HRP(Axis);
}
/** Sets the radius of the cylinder */
inline void SetRadius(float r) {
Radius = r;
this->Sync();
UpdateLocalMatrix();
}
/** Gets the radius of the cylinder */
@@ -101,7 +94,7 @@ public:
/** Sets the height of the cylinder */
inline void SetHeight(float h) {
Height = h;
this->Sync();
UpdateLocalMatrix();
}
/** Gets the height of the cylinder */
@@ -110,7 +103,7 @@ public:
/** Sets the main axis (0=X, 1=Y, 2=Z) */
inline void SetAxis(int axis) {
Axis = axis;
this->Sync();
UpdateLocalMatrix();
}
/** Gets the main axis */
@@ -164,36 +157,25 @@ public:
return Vector3f(r, theta, h);
}
/** Translate using transformation chain */
using AffineTransform::Translate;
/** Rotate using transformation chain */
using AffineTransform::Rotate;
/** Scale using transformation chain */
using AffineTransform::Scale;
signals:
/** Signal emitted when properties change */
virtual void Updated() override {
// 1. Synchronize local cylinder part (Radius/Height/Axis -> m_LocalT)
this->Sync();
// 2. Synchronize TRS part (position/rotation/scaling -> m_T) and emit signal
this->TRS::Updated();
this->UpdateLocalMatrix();
ULIB_SIGNAL_EMIT(Cylinder::Updated);
}
private:
/** Synchronizes internal transformation with properties */
void Sync() {
m_LocalT = AffineTransform(this);
if (Axis == 0) m_LocalT.Scale(Vector3f(Height, Radius, Radius));
else if (Axis == 1) m_LocalT.Scale(Vector3f(Radius, Height, Radius));
else m_LocalT.Scale(Vector3f(Radius, Radius, Height));
}
/** Recalculates the internal local matrix based on dimensions and axis */
void UpdateLocalMatrix() {
m_LocalT = AffineTransform(this);
if (Axis == 0) m_LocalT.Scale(Vector3f(Height, Radius, Radius));
else if (Axis == 1) m_LocalT.Scale(Vector3f(Radius, Height, Radius));
else m_LocalT.Scale(Vector3f(Radius, Radius, Height));
}
private:
float Radius;
float Height;
int Axis;
AffineTransform m_LocalT;
};

49
src/Math/Dense.h
View File

@@ -50,9 +50,9 @@
// #include <Eigen/src/Core/Matrix.h>
#include <stdlib.h>
#include "Core/Property.h"
#include "Core/Types.h"
#include <Eigen/Dense>
#include "Core/Types.h"
#include "Core/Property.h"
//// BOOST SERIALIZATION ///////////////////////////////////////////////////////
@@ -150,6 +150,7 @@ typedef Eigen::MatrixXi MatrixXi;
typedef Eigen::MatrixXf MatrixXf;
typedef Eigen::MatrixXd MatrixXd;
////////////////////////////////////////////////////////////////////////////////
// Vector String interaction ///////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -191,7 +192,7 @@ std::string VectorxT_ToString(const Eigen::Matrix<T, size, 1> &vec) {
// }
template <typename T, int size>
void operator>>(std::string &str, Eigen::Matrix<T, size, 1> &vec) {
void operator >> (std::string &str, Eigen::Matrix<T, size, 1> &vec) {
VectorxT_StringTo(vec, str);
}
@@ -204,7 +205,9 @@ public:
typedef Eigen::Matrix<Scalarf, 4, 1> BaseClass;
_HPoint3f() : BaseClass(0, 0, 0, p) {}
_HPoint3f(int rows, int cols) : BaseClass() { this->operator()(3) = p; }
_HPoint3f(int rows, int cols) : BaseClass() {
this->operator()(3) = p;
}
_HPoint3f(float x, float y, float z) : BaseClass(x, y, z, p) {}
_HPoint3f(Vector3f &in) : BaseClass(in.homogeneous()) {
this->operator()(3) = p;
@@ -247,24 +250,24 @@ struct _HError3f {
HVector3f position_error;
HVector3f direction_error;
};
typedef struct _HError3f HError3f;
typedef struct _HError3f HError3f;
inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
stream << "HError3f(" << "ept[" << err.position_error.transpose()
<< "] , edr[" << err.direction_error.transpose() << "]) ";
return stream;
}
typedef Property<Scalari> ScalariProperty;
typedef Property<Scalarui> ScalaruiProperty;
typedef Property<Scalarl> ScalarlProperty;
typedef Property<Scalarul> ScalarulProperty;
typedef Property<Scalarf> ScalarfProperty;
typedef Property<Scalard> ScalardProperty;
inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
stream << "HError3f(" << "ept[" << err.position_error.transpose()
<< "] , edr[" << err.direction_error.transpose() << "]) ";
return stream;
}
typedef Property<Scalari> ScalariProperty;
typedef Property<Scalarui> ScalaruiProperty;
typedef Property<Scalarl> ScalarlProperty;
typedef Property<Scalarul> ScalarulProperty;
typedef Property<Scalarf> ScalarfProperty;
typedef Property<Scalard> ScalardProperty;
typedef Property<Vector1i> Vector1iProperty;
typedef Property<Vector1f> Vector1fProperty;
typedef Property<Vector1d> Vector1dProperty;
typedef Property<Vector1i> Vector1iProperty;
typedef Property<Vector1f> Vector1fProperty;
typedef Property<Vector1d> Vector1dProperty;
typedef Property<Vector2i> Vector2iProperty;
typedef Property<Vector3i> Vector3iProperty;
@@ -291,9 +294,9 @@ typedef Property<Matrix3d> Matrix3dProperty;
typedef Property<Matrix4d> Matrix4dProperty;
typedef Property<HVector3f> HVector3fProperty;
typedef Property<HPoint3f> HPoint3fProperty;
typedef Property<HPoint3f> HPoint3fProperty;
} // namespace uLib
} // namespace uLib
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

148
src/Math/Geometry.h
View File

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

42
src/Math/Makefile.am Normal file
View File

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

9
src/Math/MathRegistrations.cpp
View File

@@ -1,19 +1,18 @@
#include "Core/ObjectFactory.h"
#include "Math/Assembly.h"
#include "Math/ContainerBox.h"
#include "Math/Cylinder.h"
#include "Math/Geometry.h"
#include "Math/QuadMesh.h"
#include "Math/StructuredData.h"
#include "Math/TriangleMesh.h"
#include "Math/QuadMesh.h"
#include "Math/VoxImage.h"
#include "Math/StructuredData.h"
namespace uLib {
ULIB_REGISTER_OBJECT(TRS)
ULIB_REGISTER_OBJECT(ContainerBox)
ULIB_REGISTER_OBJECT(Cylinder)
ULIB_REGISTER_OBJECT(Assembly)
ULIB_REGISTER_OBJECT(CylindricalGeometry)
ULIB_REGISTER_OBJECT(SphericalGeometry)
ULIB_REGISTER_OBJECT(TriangleMesh)
ULIB_REGISTER_OBJECT(QuadMesh)
ULIB_REGISTER_OBJECT_NAME(VoxImage<Voxel>, "VoxImage")

2
src/Math/Polydata.h
View File

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

5
src/Math/QuadMesh.h
View File

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

246
src/Math/Transform.h
View File

@@ -23,6 +23,8 @@
//////////////////////////////////////////////////////////////////////////////*/
/*
* Copyright (C) 2012 Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>
*
@@ -43,221 +45,115 @@
*
*/
#ifndef U_TRANSFORM_H
#define U_TRANSFORM_H
#include "Math/Dense.h"
#include "Math/Units.h"
#include <Eigen/Geometry>
#include "Math/Dense.h"
namespace uLib {
using Eigen::Isometry3d;
using Eigen::Isometry3f;
using Eigen::Affine3d;
using Eigen::Affine3f;
using Eigen::Projective3d;
using Eigen::Projective3f;
////////////////////////////////////////////////////////////////////////////////
///////// AFFINE TRANSFORM WRAPPER //////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
class AffineTransform : virtual public Object {
class AffineTransform {
protected:
Eigen::Affine3f m_T;
AffineTransform *m_Parent;
public:
uLibTypeMacro(AffineTransform, Object) protected :
AffineTransform() :
m_T(Matrix4f::Identity()),
m_Parent(NULL)
{}
Affine3f m_T;
AffineTransform *m_Parent;
virtual ~AffineTransform() {}
public:
AffineTransform() : m_T(Matrix4f::Identity()), m_Parent(NULL) {}
AffineTransform(AffineTransform *parent) :
m_T(Matrix4f::Identity()),
m_Parent(parent)
{}
AffineTransform(AffineTransform *parent)
: m_T(Matrix4f::Identity()), m_Parent(parent) {}
AffineTransform(const AffineTransform &copy) :
m_T(copy.m_T),
m_Parent(copy.m_Parent)
{}
AffineTransform(const AffineTransform &copy)
: m_T(copy.m_T), m_Parent(copy.m_Parent) {}
Eigen::Affine3f& GetTransform() { return m_T; }
Affine3f &GetTransform() { return m_T; }
AffineTransform *GetParent() const { return this->m_Parent; }
AffineTransform *GetParent() const { return this->m_Parent; }
void SetParent(AffineTransform *name) { this->m_Parent = name; }
void SetParent(AffineTransform *name) { this->m_Parent = name; }
void SetMatrix (Matrix4f mat) { m_T.matrix() = mat; }
Matrix4f GetMatrix() const { return m_T.matrix(); }
void SetMatrix(const Matrix4f &mat) { m_T.matrix() = mat; }
Matrix4f &GetMatrix() { return m_T.matrix(); }
const Matrix4f &GetMatrix() const { return m_T.matrix(); }
Matrix4f GetWorldMatrix() const
{
if(!m_Parent) return m_T.matrix();
else return m_Parent->GetWorldMatrix() * m_T.matrix(); // T = B * A //
}
Matrix4f GetWorldMatrix() const {
if (!m_Parent)
return m_T.matrix();
else
return m_Parent->GetWorldMatrix() * m_T.matrix(); // T = B * A //
}
void SetPosition(const Vector3f v) { this->m_T.translation() = v; }
void SetWorldMatrix(const Matrix4f &mat) {
if (!m_Parent)
m_T.matrix() = mat;
else
m_T.matrix() = m_Parent->GetWorldMatrix().inverse() * mat;
}
Vector3f GetPosition() const { return this->m_T.translation(); }
void SetPosition(const Vector3f &v) { this->m_T.translation() = v; }
void SetRotation(const Matrix3f m) { this->m_T.linear() = m; }
Vector3f GetPosition() const { return this->m_T.translation(); }
Matrix3f GetRotation() const { return this->m_T.rotation(); }
void SetRotation(const Matrix3f &m) { this->m_T.linear() = m; }
void Translate(const Vector3f v) { this->m_T.translate(v); }
Matrix3f GetRotation() const { return this->m_T.rotation(); }
void Scale(const Vector3f v) { this->m_T.scale(v); }
void Translate(const Vector3f &v) { this->m_T.translate(v); }
Vector3f GetScale() const {
return Vector3f(m_T.linear().col(0).norm(),
m_T.linear().col(1).norm(),
m_T.linear().col(2).norm());
}
void Scale(const Vector3f &v) { this->m_T.scale(v); }
Vector3f GetScale() const {
return Vector3f(this->m_T.linear().col(0).norm(),
this->m_T.linear().col(1).norm(),
this->m_T.linear().col(2).norm());
}
void Rotate(const Matrix3f m) { this->m_T.rotate(m); }
void Rotate(const Matrix3f &m) { this->m_T.rotate(m); }
void Rotate(const float angle, Vector3f axis)
{
axis.normalize(); // prehaps not necessary ( see eigens )
Eigen::AngleAxisf ax(angle,axis);
this->m_T.rotate(Eigen::Quaternion<float>(ax));
}
void Rotate(const float angle, Vector3f axis) {
axis.normalize(); // prehaps not necessary ( see eigens )
Eigen::AngleAxisf ax(angle, axis);
this->m_T.rotate(Eigen::Quaternion<float>(ax));
}
void Rotate(const Vector3f euler_axis) {
float angle = euler_axis.norm();
Rotate(angle,euler_axis);
}
void Rotate(const Vector3f euler_axis) {
float angle = euler_axis.norm();
Rotate(angle, euler_axis);
}
void PreRotate(const Matrix3f m) { this->m_T.prerotate(m); }
void PreRotate(const Matrix3f &m) { this->m_T.prerotate(m); }
void QuaternionRotate(const Vector4f q)
{ this->m_T.rotate(Eigen::Quaternion<float>(q)); }
void QuaternionRotate(const Vector4f &q) {
this->m_T.rotate(Eigen::Quaternion<float>(q));
}
void EulerYZYRotate(const Vector3f e) {
Matrix3f mat;
mat = Eigen::AngleAxisf(e.x(), Vector3f::UnitY())
* Eigen::AngleAxisf(e.y(), Vector3f::UnitZ())
* Eigen::AngleAxisf(e.z(), Vector3f::UnitY());
m_T.rotate(mat);
}
void EulerYZYRotate(const Vector3f &e) {
Matrix3f mat;
mat = Eigen::AngleAxisf(e.x(), Vector3f::UnitY()) *
Eigen::AngleAxisf(e.y(), Vector3f::UnitZ()) *
Eigen::AngleAxisf(e.z(), Vector3f::UnitY());
m_T.rotate(mat);
}
void FlipAxes(int first, int second) {
Matrix3f mat = Matrix3f::Identity();
mat.col(first).swap(mat.col(second));
m_T.rotate(mat);
}
void FlipAxes(int first, int second)
{
Matrix3f mat = Matrix3f::Identity();
mat.col(first).swap(mat.col(second));
m_T.rotate(mat);
}
};
////////////////////////////////////////////////////////////////////////////////
///////// TRS PARAMETERS /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
typedef Eigen::Affine3f AffineMatrix;
class TRS : public AffineTransform {
uLibTypeMacro(TRS, AffineTransform) ULIB_SERIALIZE_ACCESS
// ULIB_DECLARE_PROPERTIES(TRS)
public :
Vector3f position = Vector3f::Zero();
Vector3f rotation = Vector3f::Zero();
Vector3f scaling = Vector3f::Ones();
TRS() = default;
TRS(const class AffineTransform &at) { this->FromMatrix(at.GetMatrix()); }
TRS(const Matrix4f &mat) { this->FromMatrix(mat); }
void FromMatrix(const Matrix4f &mat) {
this->position = mat.block<3, 1>(0, 3);
Matrix3f linear = mat.block<3, 3>(0, 0);
this->scaling(0) = linear.col(0).norm();
this->scaling(1) = linear.col(1).norm();
this->scaling(2) = linear.col(2).norm();
Matrix3f rot = linear;
if (this->scaling(0) > 1e-6)
rot.col(0) /= this->scaling(0);
if (this->scaling(1) > 1e-6)
rot.col(1) /= this->scaling(1);
if (this->scaling(2) > 1e-6)
rot.col(2) /= this->scaling(2);
Vector3f euler = rot.canonicalEulerAngles(2, 1, 0);
this->rotation = Vector3f(euler(2), euler(1), euler(0));
this->SetMatrix(mat);
this->NotifyPropertiesUpdated();
}
void SetPosition(const Vector3f &v) {
position = v;
this->AffineTransform::SetPosition(v);
}
void SetRotation(const Vector3f &v) {
rotation = v;
this->SyncMatrix();
}
void SetOrientation(const Vector3f &v) { SetRotation(v); }
void SetScale(const Vector3f &v) {
scaling = v;
this->SyncMatrix();
}
void SyncMatrix() { this->GetTransform() = GetAffineMatrix(); }
void Updated() override {
this->SyncMatrix();
this->NotifyPropertiesUpdated();
this->AffineTransform::Updated();
}
template <class ArchiveT>
void serialize(ArchiveT &ar, const unsigned int version) {
ar &HRPU(position, "mm");
ar &HRPU(rotation, "rad");
ar &HRP(scaling);
}
AffineMatrix GetAffineMatrix() const {
AffineMatrix m = AffineMatrix::Identity();
m.translate(position);
m.rotate(Eigen::AngleAxisf(rotation.z(), Vector3f::UnitZ()));
m.rotate(Eigen::AngleAxisf(rotation.y(), Vector3f::UnitY()));
m.rotate(Eigen::AngleAxisf(rotation.x(), Vector3f::UnitX()));
m.scale(scaling);
return m;
}
Matrix4f GetMatrix() const { return this->GetAffineMatrix().matrix(); }
};
inline std::ostream &operator<<(std::ostream &os, const TRS &trs) {
os << trs.position << " " << trs.rotation << " " << trs.scaling;
return os;
}
inline std::istream &operator>>(std::istream &is, TRS &trs) {
is >> trs.position >> trs.rotation >> trs.scaling;
return is;
}
} // namespace uLib
#endif // U_TRANSFORM_H
#endif//U_TRANSFORM_H

5
src/Math/TriangleMesh.h
View File

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

62
src/Math/Units.h
View File

@@ -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""_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""_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""_km(long double v) { return static_cast<double>(v) * CLHEP::kilometer; }
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"" _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"" _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""_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""_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""_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"" _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"" _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"" _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""_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""_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"" _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"" _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""_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""_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""_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"" _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"" _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"" _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""_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""_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""_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""_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""_GeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
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"" _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"" _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"" _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"" _GeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
}
}

2
src/Math/VoxImage.h
View File

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

16
src/Math/VoxImageFilter.h
View File

@@ -27,6 +27,7 @@
#define VOXIMAGEFILTER_H
#include "Core/StaticInterface.h"
#include "Core/Algorithm.h"
#include "Math/Dense.h"
#include "Math/VoxImage.h"
@@ -57,14 +58,25 @@ protected:
} // namespace Abstract
template <typename VoxelT, typename AlgorithmT>
class VoxImageFilter : public Abstract::VoxImageFilter, public Object {
class VoxImageFilter : public Abstract::VoxImageFilter,
public Algorithm<VoxImage<VoxelT>*, VoxImage<VoxelT>*> {
public:
virtual const char * GetClassName() const { return "VoxImageFilter"; }
VoxImageFilter(const Vector3i &size);
/**
* @brief Process implements Algorithm::Process.
* Applies the filter in-place on the input image and returns it.
*/
VoxImage<VoxelT>* Process(VoxImage<VoxelT>* const& image) override;
/**
* @brief Run implements Abstract::VoxImageFilter::Run.
* Calls Process on the current image.
*/
void Run();
void SetKernelNumericXZY(const std::vector<float> &numeric);

58
src/Math/VoxImageFilter.hpp
View File

@@ -98,23 +98,31 @@ template <typename T> void Kernel<T>::PrintSelf(std::ostream &o) const {
////////////////////////////////////////////////////////////////////////////////
#define _TPL_ template <typename VoxelT, typename AlgorithmT>
#define _TPLT_ VoxelT, AlgorithmT
template <typename VoxelT, typename AlgorithmT>
VoxImageFilter<VoxelT, AlgorithmT>::VoxImageFilter(const Vector3i &size)
_TPL_
VoxImageFilter<_TPLT_>::VoxImageFilter(const Vector3i &size)
: m_KernelData(size), t_Algoritm(static_cast<AlgorithmT *>(this)) {}
template <typename VoxelT, typename AlgorithmT>
void VoxImageFilter<VoxelT, AlgorithmT>::Run() {
_TPL_
VoxImage<VoxelT>* VoxImageFilter<_TPLT_>::Process(VoxImage<VoxelT>* const& image) {
if (m_Image != image) SetImage(image);
VoxImage<VoxelT> buffer = *m_Image;
#pragma omp parallel for
for (int i = 0; i < m_Image->Data().size(); ++i)
m_Image->operator[](i).Value = this->t_Algoritm->Evaluate(buffer, i);
#pragma omp barrier
return m_Image;
}
template <typename VoxelT, typename AlgorithmT>
void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelOffset() {
_TPL_
void VoxImageFilter<_TPLT_>::Run() {
Process(m_Image);
}
_TPL_
void VoxImageFilter<_TPLT_>::SetKernelOffset() {
Vector3i id(0, 0, 0);
for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
@@ -126,8 +134,8 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelOffset() {
}
}
template <typename VoxelT, typename AlgorithmT>
float VoxImageFilter<VoxelT, AlgorithmT>::Distance2(const Vector3i &v) {
_TPL_
float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v) {
Vector3i tmp = v;
const Vector3i &dim = this->m_KernelData.GetDims();
Vector3i center = dim / 2;
@@ -139,8 +147,8 @@ float VoxImageFilter<VoxelT, AlgorithmT>::Distance2(const Vector3i &v) {
0.25 * (3 - (dim(0) % 2) - (dim(1) % 2) - (dim(2) % 2)));
}
template <typename VoxelT, typename AlgorithmT>
void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelNumericXZY(
_TPL_
void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(
const std::vector<float> &numeric) {
// set data order //
StructuredData::Order order = m_KernelData.GetDataOrder();
@@ -158,8 +166,8 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelNumericXZY(
// m_KernelData.SetDataOrder(order);
}
template <typename VoxelT, typename AlgorithmT>
void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelSpherical(float (*shape)(float)) {
_TPL_
void VoxImageFilter<_TPLT_>::SetKernelSpherical(float (*shape)(float)) {
Vector3i id;
for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
@@ -171,8 +179,8 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelSpherical(float (*shape)(float
}
}
template <typename VoxelT, typename AlgorithmT> template <class ShapeT>
void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelSpherical(ShapeT shape) {
_TPL_ template <class ShapeT>
void VoxImageFilter<_TPLT_>::SetKernelSpherical(ShapeT shape) {
Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
Vector3i id;
for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
@@ -185,8 +193,8 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelSpherical(ShapeT shape) {
}
}
template <typename VoxelT, typename AlgorithmT>
void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(
_TPL_
void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(
float (*shape)(const Vector3f &)) {
const Vector3i &dim = m_KernelData.GetDims();
Vector3i id;
@@ -206,8 +214,8 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(
}
}
template <typename VoxelT, typename AlgorithmT> template <class ShapeT>
void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(ShapeT shape) {
_TPL_ template <class ShapeT>
void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(ShapeT shape) {
Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
const Vector3i &dim = m_KernelData.GetDims();
Vector3i id;
@@ -227,14 +235,14 @@ void VoxImageFilter<VoxelT, AlgorithmT>::SetKernelWeightFunction(ShapeT shape) {
}
}
template <typename VoxelT, typename AlgorithmT>
void VoxImageFilter<VoxelT, AlgorithmT>::SetImage(Abstract::VoxImage *image) {
_TPL_
void VoxImageFilter<_TPLT_>::SetImage(Abstract::VoxImage *image) {
this->m_Image = reinterpret_cast<VoxImage<VoxelT> *>(image);
this->SetKernelOffset();
}
template <typename VoxelT, typename AlgorithmT>
float VoxImageFilter<VoxelT, AlgorithmT>::Convolve(const VoxImage<VoxelT> &buffer,
_TPL_
float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer,
int index) {
const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
const DataAllocator<VoxelT> &vker = m_KernelData.ConstData();
@@ -251,8 +259,8 @@ float VoxImageFilter<VoxelT, AlgorithmT>::Convolve(const VoxImage<VoxelT> &buffe
return conv / ksum;
}
#undef _TPLT_
#undef _TPL_
} // namespace uLib

25
src/Math/testing/GeometryTest.cpp
View File

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

6
src/Math/testing/testing-prototype.h
View File

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

57
src/Python/math_bindings.cpp
View File

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

6
src/Root/CMakeLists.txt
View File

@@ -33,11 +33,7 @@ set(DICTIONARY_HEADERS muCastorMCTrack.h
SkinDetectorWriter.h)
set(LIBRARIES ${ROOT_LIBRARIES}
${PACKAGE_LIBPREFIX}Math
Eigen3::Eigen)
get_target_property(EIGEN3_INC Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
include_directories(${EIGEN3_INC})
${PACKAGE_LIBPREFIX}Math)
set(rDictName ${PACKAGE_LIBPREFIX}RootDict)
root_generate_dictionary(${rDictName} ${DICTIONARY_HEADERS}

110
src/Root/muCastorMCTrack.h
View File

@@ -1,84 +1,88 @@
#ifndef muCastor_MCTRACK_H
#define muCastor_MCTRACK_H
// ########################################
// muCastorMCTrack class
// Created at the University of Brescia, Italy
// Date: December 2011
// Autors: Germano Bonomi germano.bonomi@ing.unibs.it
// Martin Subieta martin.subieta@ing.unibs.it
// ########################################
//########################################
// muCastorMCTrack class
// Created at the University of Brescia, Italy
// Date: December 2011
// Autors: Germano Bonomi germano.bonomi@ing.unibs.it
// Martin Subieta martin.subieta@ing.unibs.it
//########################################
#include "Detectors/MuonScatter.h"
#include <iostream>
#include "vector"
#include "TObject.h"
#include "TParticle.h"
#include "vector"
#include <iostream>
#include "Detectors/MuonScatter.h"
class TClonesArray;
class muCastorMCTrack : public TObject {
class muCastorMCTrack : public TObject
{
public:
public:
/** Default constructor **/
muCastorMCTrack();
/** Constructor from TParticle **/
muCastorMCTrack(TParticle *particle);
muCastorMCTrack(TParticle* particle);
/** Destructor **/
virtual ~muCastorMCTrack();
void Reset();
void Reset();
/** Accessors **/
Int_t GetFirstDaughter() const { return fDaughter[0]; }
Int_t GetMother() const { return fMother[0]; }
Int_t GetFirstDaughter() const { return fDaughter[0];}
Int_t GetMother() const { return fMother[0];}
/** Modifiers **/
virtual void AddPoint(TLorentzVector pos, TLorentzVector mom);
virtual void SetFirstDaughter(Int_t trkid) { fDaughter[0] = trkid; }
virtual void SetLastDaughter(Int_t trkid) { fDaughter[1] = trkid; }
virtual void AddPoint(TLorentzVector pos, TLorentzVector mom);
virtual void SetFirstDaughter(Int_t trkid) { fDaughter[0] = trkid; }
virtual void SetLastDaughter(Int_t trkid) { fDaughter[1] = trkid; }
inline void Dump() {
std::cout << "muCastorMCTrack\n"
<< "PDG code: " << fPdgCode << "\n"
<< "Momentum: " << fPx << ", " << fPy << ", " << fPz << "\n"
<< "Position: " << fVx << ", " << fVy << ", " << fVz << "\n"
<< "Npoints: " << fNpoints << "\n";
return;
}
inline void Dump() {
std::cout << "muCastorMCTrack\n"
<< "PDG code: " << fPdgCode << "\n"
<< "Momentum: " << fPx << ", " << fPy << ", " << fPz << "\n"
<< "Position: " << fVx << ", " << fVy << ", " << fVz << "\n"
<< "Npoints: " << fNpoints << "\n";
return;
}
public:
/* Private variables - copying private variables of TParticle */
Int_t fPdgCode; // PDG code of the particle
Int_t fMother[2]; // Indices of the mother particles
Int_t fDaughter[2]; // Indices of the daughter particles
/* Private variables - copying private variables of TParticle */
Double_t fPx; // x component of momentum
Double_t fPy; // y component of momentum
Double_t fPz; // z component of momentum
Double_t fE; // Energy
Int_t fPdgCode; // PDG code of the particle
Int_t fMother[2]; // Indices of the mother particles
Int_t fDaughter[2]; // Indices of the daughter particles
Double_t fVx; // x of production vertex
Double_t fVy; // y of production vertex
Double_t fVz; // z of production vertex
Double_t fVt; // t of production vertex
Double_t fPx; // x component of momentum
Double_t fPy; // y component of momentum
Double_t fPz; // z component of momentum
Double_t fE; // Energy
Int_t fPointsSize; // capacity of points array
Int_t fNpoints; // number of stored points
Double_t *fPntPosX; //[fNpoints] array of points (x) belonging to this track
Double_t *fPntPosY; //[fNpoints] array of points (y) belonging to this track
Double_t *fPntPosZ; //[fNpoints] array of points (z) belonging to this track
Double_t *fPntT; //[fNpoints] array of points (t) belonging to this track
Double_t *fPntMomX; //[fNpoints] array of points (px) belonging to this track
Double_t *fPntMomY; //[fNpoints] array of points (py) belonging to this track
Double_t *fPntMomZ; //[fNpoints] array of points (pz) belonging to this track
Double_t *fPntE; //[fNpoints] array of points (E) belonging to this track
Double_t fVx; // x of production vertex
Double_t fVy; // y of production vertex
Double_t fVz; // z of production vertex
Double_t fVt; // t of production vertex
Int_t fPointsSize; // capacity of points array
Int_t fNpoints; // number of stored points
Double_t *fPntPosX; //[fNpoints] array of points (x) belonging to this track
Double_t *fPntPosY; //[fNpoints] array of points (y) belonging to this track
Double_t *fPntPosZ; //[fNpoints] array of points (z) belonging to this track
Double_t *fPntT; //[fNpoints] array of points (t) belonging to this track
Double_t *fPntMomX; //[fNpoints] array of points (px) belonging to this track
Double_t *fPntMomY; //[fNpoints] array of points (py) belonging to this track
Double_t *fPntMomZ; //[fNpoints] array of points (pz) belonging to this track
Double_t *fPntE; //[fNpoints] array of points (E) belonging to this track
ClassDef(muCastorMCTrack,1);
ClassDef(muCastorMCTrack, 1);
};
uLib::MuonScatter &operator<<(uLib::MuonScatter &mu,
const muCastorMCTrack &bsmu);
#endif // muCastor_MCTRACK_H
uLib::MuonScatter &operator << (uLib::MuonScatter &mu, const muCastorMCTrack &bsmu);
#endif //muCastor_MCTRACK_H

8
src/Vtk/CMakeLists.txt
View File

@@ -3,8 +3,8 @@ set(HEADERS uLibVtkInterface.h
vtkHandlerWidget.h
vtkQViewport.h
vtkViewport.h
vtkPolydata.h
vtkObjectsContext.h
vtkMultiSelectionProp.h
)
set(SOURCES uLibVtkInterface.cxx
@@ -12,8 +12,8 @@ set(SOURCES uLibVtkInterface.cxx
vtkHandlerWidget.cpp
vtkQViewport.cpp
vtkViewport.cpp
vtkPolydata.cpp
vtkObjectsContext.cpp
vtkMultiSelectionProp.cpp
)
## Pull in Math VTK wrappers (sets MATH_SOURCES / MATH_HEADERS)
@@ -39,8 +39,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)
@@ -60,7 +58,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"

16
src/Vtk/HEP/Detectors/testing/vtkDetectorChamberTest.cpp
View File

@@ -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::DetectorChamber v_d2(&d2);
v_d1.SetRepresentation(Vtk::Prop3D::Surface);
v_d2.SetRepresentation(Vtk::Prop3D::Surface);
Vtk::vtkDetectorChamber v_d1(&d1);
Vtk::vtkDetectorChamber v_d2(&d2);
v_d1.SetRepresentation(Vtk::Puppet::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.AddProp3D(v_d2);
viewer.AddPuppet(v_d1);
viewer.AddPuppet(v_d2);
viewer.Start();
}

34
src/Vtk/HEP/Detectors/testing/vtkDetectorMuonProjectionTest.cpp
View File

@@ -23,8 +23,8 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
#include "HEP/Detectors/DetectorChamber.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
class vtkArrowProp3D : public Vtk::Prop3D {
// A simple puppet class to represent an arrow indicative of a projected muon hit
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::DetectorChamber v_d2(&d2);
Vtk::MuonScatter v_event(event);
Vtk::vtkDetectorChamber v_d1(&d1);
Vtk::vtkDetectorChamber v_d2(&d2);
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.AddProp3D(v_d2);
viewer.AddProp3D(v_event);
viewer.AddProp3D(v_p1);
viewer.AddProp3D(v_p2);
viewer.AddPuppet(v_d1);
viewer.AddPuppet(v_d2);
viewer.AddPuppet(v_event);
viewer.AddPuppet(v_p1);
viewer.AddPuppet(v_p2);
viewer.Start();
}

8
src/Vtk/HEP/Detectors/testing/vtkMuonScatterTest.cpp
View File

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

20
src/Vtk/HEP/Detectors/vtkDetectorChamber.cxx
View File

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

Some files were not shown because too many files have changed in this diff Show More