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

Compare commits

base: OpenCMT:fix-properties
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:fix-assembly
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

1 Commits
fix-proper ... fix-assemb

Author SHA1 Message Date
AndreaRigoni
010927714f not working yet 2026-04-13 07:36:19 +00:00
100 changed files with 1009 additions and 2990 deletions
Expand all files Collapse all files

49
.agents/skills/core_system.md
View File

@@ -1,49 +0,0 @@
# Skill: Core Object & Property System
This skill defines the patterns for implementing and working with the `uLib` core object model.
## Context
- **Base Class**: `uLib::Object`
- **Property System**: `uLib::Property<T>`
- **Registration**: All objects must register their properties for UI visibility and serialization.
## Implementation Patterns
### 1. Defining an Object
Inherit from `uLib::Object` and use the `ULIB_PROPERTY` macro for members.
```cpp
class MyObject : public uLib::Object {
public:
ULIB_PROPERTY(double, Speed, 0.0)
ULIB_PROPERTY(std::string, Description, "None")
MyObject() {
// Required for property visibility in PropertyEditor
ULIB_ACTIVATE_PROPERTIES(*this)
}
};
```
### 2. Property Access
Properties can be treated like their underlying types or accessed via `.Get()`/`.Set()`.
```cpp
obj.Speed = 10.5; // Triggers Updated() signal
double s = obj.Speed; // Implicit conversion
obj.Speed.SetRange(0.0, 100.0); // Setting metadata
```
### 3. Serialization
Implement `serialize` overloads for different archive types. Use `hrp` (Human Readable Property) to name fields.
```cpp
template <class ArchiveT>
void serialize(ArchiveT &ar, const unsigned int version) {
ar & boost::serialization::make_nvp("InstanceName", this->GetInstanceName());
ar & boost::serialization::make_hrp("Speed", Speed, "m/s");
}
```
## Checklist
- [ ] Inherit from `uLib::Object`.
- [ ] Use `ULIB_PROPERTY` for members that should appear in the GUI.
- [ ] Call `ULIB_ACTIVATE_PROPERTIES` in the constructor.
- [ ] Implement `serialize` if persistence is required.

39
.agents/skills/geant_simulation.md
View File

@@ -1,39 +0,0 @@
# Skill: HEP/Geant Simulation Rules
This skill provides instructions for developing the Geant4 simulation components within `uLib`.
## Context
- **Domain Objects**: `Material`, `Solid`, `LogicalVolume`, `PhysicalVolume`.
- **Integration**: `mutomGeant` library wraps Geant4 classes into `uLib::Object`s.
## Patterns
### 1. Adding a New Solid
New solids must implement `GetPolyhedron()` to support VTK visualization.
```cpp
G4Polyhedron* MySolid::GetPolyhedron() const {
// Return the tessellated representation of the Geant4 solid
return m_G4Solid->GetPolyhedron();
}
```
### 2. Physical Volume Hierarchy
Maintain the relationship between `PhysicalVolume` and its parent `LogicalVolume`.
```cpp
auto* world = new LogicalVolume(worldSolid, worldMat);
auto* detector = new PhysicalVolume(detectorLogic, world, "Detector1");
detector->SetPosition({0, 0, 100}); // Relative to parent
```
### 3. Transformation Synchronization
Use the centralized `TRS` object to manage position and rotation. Synchronization with Geant4's internal stores should be reactive.
- Listen to `Object::Updated` on the `Solid` or `PhysicalVolume`.
- Update the underlying `G4VPhysicalVolume` position/rotation.
## Material Management
Use the `Matter` class to manage Geant4 materials. Ensure materials are registered in the `G4NistManager` or custom material store if needed.
## Checklist
- [ ] Does the solid implement `GetPolyhedron()`?
- [ ] Are parents correctly assigned in `PhysicalVolume` constructors?
- [ ] Is the `TRS` object used for all spatial transformations?

40
.agents/skills/memory_management.md
View File

@@ -1,40 +0,0 @@
# Skill: Memory Management & Object Lifecycle
This skill provides guidelines for managing memory safely within the `uLib` framework to prevent memory corruption and leaks.
## Context
- **Ownership**: `ObjectsContext` typically owns its children.
- **Shared Access**: Use `SmartPointer<T>` for objects shared across multiple systems (e.g., Geant4 and VTK).
- **Core Principle**: Avoid manual `delete` on objects managed by the framework.
## Patterns
### 1. Context Ownership
When an object is added to an `ObjectsContext`, it is managed by that context.
```cpp
auto* context = new ObjectsContext();
auto* obj = new MyObject();
context->AddObject(obj);
// Do NOT delete obj; it will be deleted when context is destroyed.
```
### 2. Smart Pointers
Use `SmartPointer<T>` for resources like `Material` or `Solid` that are used by both domain logic and external engines (Geant4).
```cpp
uLib::SmartPointer<Material> mat = new Material("Lead");
solid->SetMaterial(mat); // Shared ownership
```
### 3. Geant4 Object Safety
Geant4 often takes ownership of certain objects (like `G4VPhysicalVolume`). When wrapping these:
- Ensure the wrapper doesn't double-free the Geant4-owned pointer.
- Use `recursion_guard` if synchronizing transformations between `uLib::Object` and Geant4 volumes to prevent signal loops.
## Debugging Memory Issues
- **SIGABRT (invalid pointer)**: Usually caused by deleting an object that was already managed (and deleted) by an `ObjectsContext` or `SmartPointer`.
- **Leaks**: Check if objects were created but never added to a context or wrapped in a `SmartPointer`.
## Checklist
- [ ] Are objects added to an `ObjectsContext`?
- [ ] Is `SmartPointer` used for shared resources?
- [ ] Is there a risk of double-freeing Geant4-managed pointers?

25
.agents/rules/micromamba_build.md → .agents/skills/micromamba_build.md
View File

@@ -1,10 +1,6 @@
---
trigger: always_on
---
# Skill: Build uLib with Micromamba
# Rule: Build uLib with Micromamba
This rule provides instructions for building the uLib project using the micromamba environment.
This skill provides instructions for building the uLib project using the micromamba environment.
## Context
- **Environment**: micromamba `uLib`
@@ -18,27 +14,26 @@ This rule provides instructions for building the uLib project using the micromam
```bash
export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
export MAMBA_ROOT_PREFIX="/home/share/micromamba"
export PRESET="clang-debug"
eval "$(${MAMBA_EXE} shell hook --shell bash)"
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 install . --output-folder=build/${PRESET} --build=missing --profile=fast
cmake --preset ${PRESET}
cmake --build build/${PRESET} -j$(nproc)
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/${PRESET} -j$(nproc)
cmake --build build -j$(nproc)
```
4. **Specific Target Build - gcompose**:
4. **Specific Target Build**:
To build a specific target (e.g., gcompose):
```bash
cmake --build build/${PRESET} --target gcompose -j$(nproc)
```
cmake --build build --target gcompose -j$(nproc)
```

29
.agents/skills/object_context.md
View File

@@ -1,29 +0,0 @@
# Skill: Object Context & Scene Management
Guidelines for managing the `uLib` object hierarchy, Geant4 volume instantiation, and Gcompose scene interaction.
## 1. Object Creation & Context
- **Factory Pattern**: Always use `ObjectFactory` to instantiate objects from the registry. Avoid direct `new` calls for domain objects to ensure proper metadata and property initialization.
- **Context Ownership**: The `Context` is the source of truth. Every persistent object must be registered within the `Context` to participate in the tree hierarchy, property system, and serialization.
## 2. Geant4: Logical vs. Physical Volumes
In the Geant4/HEP domain, visibility and placement follow a strict two-tier hierarchy:
- **LogicalVolume**: Defines **what** the object is (Solid/Shape, Material, and daughter volumes). It is a template and does **not** have a spatial position.
- **PhysicalVolume**: Defines **where** and **how** an instance exists. It references a `LogicalVolume` and holds the **TRS** (Translation, Rotation Matrix/Scale).
- **CRITICAL**: Adding a `Solid` or `LogicalVolume` to the scene is insufficient for visualization. To display an object in the VTK viewport, you **must**:
1. Define the `LogicalVolume`.
2. Instantiate a `PhysicalVolume` from that `LogicalVolume`.
3. Add the `PhysicalVolume` to the scene context and apply TRS transformations to it.
## 3. Gcompose: Tree Hierarchy & Visualization
- **3D Representations**: Objects with 3D actors are automatically wrapped in VTK representations (e.g., `vtkContainerBox`). Non-3D objects remain in the tree but have no viewport presence.
- **Reference Handling**:
- Internal object references (raw pointers or `SmartPointer`) are rendered as "virtual children" in the tree.
- **Instance Re-use**: One object can appear as a child under multiple parents if referenced multiple times; these are placeholders for the same underlying instance.
- **Setting References**:
- **Property Selector**: Filter and select compatible types from the global context within the property editor.
- **Drag & Drop**: Drag an object from the tree and drop it onto a property field. The system automatically validates types and performs the necessary casting/assignment.
## 4. Best Practices & Checks
- **TRS Logic**: Always apply transformations to the `PhysicalVolume`. Changes to a `LogicalVolume` will affect all its instances but will not move them.
- **Dependency Tracking**: Use the tree structure to identify shared references. Changing a property on a shared object affects all parent nodes that reference it.

34
.agents/skills/signal_bridge.md
View File

@@ -1,34 +0,0 @@
# Skill: Multi-System Signaling (uLib ↔ Qt)
This skill manages the coexistence of `uLib::Object` signals and Qt's `Q_OBJECT` signaling system.
## Context
- **uLib Signals**: Used for domain logic and data changes (`uLib::Object::connect`).
- **Qt Signals**: Used for UI events, widgets, and application-level control flow (`QObject::connect`).
## Patterns
### 1. Bridging Logic
When a domain change needs to trigger a UI update, use a wrapper or a direct connection if the widget has access to the `uLib::Object`.
```cpp
// In a Qt Widget
uLib::Object::connect(domainObj, &Object::Updated, [this]() {
this->update(); // Trigger Qt repaint
});
```
### 2. Selection Flow
Selection usually starts in the VTK Viewport (Qt) and flows to the domain context.
1. `QViewport` emits `prop3dSelected(Prop3D*)` (Qt signal).
2. `MainPanel` catches it and calls `contextPanel->selectObject(p->GetContent())`.
3. `ContextPanel` updates the tree view and property editors.
### 3. Connection Hygiene
- Use `uLib::Object::connect` for everything involving `uLib::Property` changes.
- Use Qt `connect` for button clicks, menu actions, and window events.
- Be careful with lambda captures; ensure the captured object is still alive or use weak pointers if necessary.
## Checklist
- [ ] Is the correct signaling system being used for the task?
- [ ] Are capture groups in lambdas safe?
- [ ] Does selection flow correctly between the 3D view and the tree view?

34
.agents/skills/testing_guide.md
View File

@@ -1,34 +0,0 @@
# Skill: Standardized Testing & Validation
This skill provides the standard workflow for testing and validating changes in the `uLib` project.
## Context
- **Tooling**: `ctest` and direct execution of test binaries in the `build/` directory.
- **Location**: Test binaries are typically located in `build/src/*/testing/` or `build/Testing/`.
## Workflow
### 1. Running All Tests
From the root directory:
```bash
ctest --test-dir build/clang-make --output-on-failure
```
### 2. Running Component Tests
Run specific categories of tests:
- **Core**: `./build/clang-make/src/Core/testing/CoreTest`
- **Math**: `./build/clang-make/src/Math/testing/MathVectorTest`
- **Geant**: `./build/clang-make/src/HEP/Geant/testing/GeantApp`
- **VTK**: `./build/clang-make/src/Vtk/testing/vtkViewerTest`
### 3. Debugging a Failing Test
Run the binary directly through `gdb` or `valgrind` (if available):
```bash
gdb --args ./build/clang-make/src/Core/testing/ObjectWrapperTest
```
## Validation Checklist for New Features
- [ ] Does `ctest` pass globally?
- [ ] If changing visualization, does `vtkViewerTest` show the correct results?
- [ ] If changing Geant logic, does `GeantApp` run without memory aborts?
- [ ] Are new tests added to the appropriate `CMakeLists.txt`?

52
.agents/skills/vtk_visualization.md
View File

@@ -1,52 +0,0 @@
# Skill: VTK Visualization Pipeline
This skill defines how to bridge domain objects with the VTK 3D visualization layer.
## Context
- **Wrapper**: `Prop3D` (wraps a `vtkProp`).
- **Mapping**: `Viewport` maintains `m_ObjectToProp3D` for synchronization.
- **GUI Integration**: `QViewport` handles Qt events and selection signals.
## Implementation Patterns
### 1. Creating a Prop3D
A `Prop3D` should wrap a domain object and update its visual state when the object changes.
```cpp
class MyProp3D : public Prop3D {
public:
MyProp3D(MyObject* obj) : Prop3D(obj) {
// Connect domain updates to visual refreshes
uLib::Object::connect(obj, &Object::Updated, [this]() { this->SyncFromObject(); });
// Expose properties to the VTK side-panel
ULIB_ACTIVATE_DISPLAY_PROPERTIES(*this)
}
void SyncFromObject() {
// Update VTK actors/mappers from MyObject's properties
}
};
```
### 2. Display Properties
Use `serialize_display` to choose which properties of the domain object or the `Prop3D` itself are visible in the sliding "Display Properties" panel in `gcompose`.
```cpp
void serialize_display(Archive::display_properties_archive &ar) {
ar & boost::serialization::make_hrp("Opacity", m_Opacity);
ar & boost::serialization::make_hrp("Wireframe", m_Wireframe);
}
```
### 3. Transformation Sync (TRS)
Always synchronize the object's `trs` (Translate, Rotate, Scale) with the VTK actor's user transform.
```cpp
void UpdateTransform() {
auto matrix = GetContent()->GetTransform().GetMatrix();
m_Actor->SetUserMatrix(uLib::ToVtkMatrix(matrix));
}
```
## Checklist
- [ ] Does the `Prop3D` connect to the object's `Updated()` signal?
- [ ] Are `ULIB_ACTIVATE_DISPLAY_PROPERTIES` and `serialize_display` implemented?
- [ ] Is the transformation (TRS) correctly mapped to the VTK actor?

3
.gitignore vendored
View File

@@ -20,6 +20,3 @@ test_boost.cpp
.claude/settings.json
build_output.log
configure_output.log
test.xml
test_ref_smartpointer.xml
test_ref.xml

22
.vscode/settings.json vendored
View File

@@ -1,14 +1,13 @@
{
"clangd.path": "/home/share/micromamba/envs/uLib/bin/clangd",
"clangd.fallbackFlags": [
"-I/home/rigoni/devel/cmt/uLib/src",
"-isystem/home/share/micromamba/envs/uLib/include",
"-isystem/home/share/micromamba/envs/uLib/include/eigen3",
"-isystem/home/share/micromamba/envs/uLib/targets/x86_64-linux/include",
"-isystem/home/share/micromamba/envs/uLib/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
"-isystem/home/share/micromamba/envs/uLib/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
"-isystem/home/share/micromamba/envs/uLib/x86_64-conda-linux-gnu/sysroot/usr/include",
"--gcc-toolchain=/home/share/micromamba/envs/uLib",
"-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",
"-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
"-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
"-isystem/home/share/micromamba/envs/mutom/x86_64-conda-linux-gnu/sysroot/usr/include",
"--gcc-toolchain=/home/share/micromamba/envs/mutom",
"-D__host__=",
"-D__device__=",
"-D__global__=",
@@ -19,8 +18,8 @@
],
"clangd.semanticHighlighting.enable": true,
"clangd.arguments": [
"--compile-commands-dir=build/clang-make",
"--query-driver=/home/share/micromamba/envs/uLib/bin/*",
"--compile-commands-dir=build",
"--query-driver=/home/share/micromamba/envs/mutom/bin/*",
"--all-scopes-completion",
"--completion-style=detailed",
"--header-insertion=never",
@@ -28,6 +27,5 @@
"--pch-storage=memory",
"--background-index",
"--log=verbose"
],
"C_Cpp.intelliSenseEngine": "disabled"
]
}

21
CMakeLists.txt
View File

@@ -3,31 +3,10 @@
##### CMAKE LISTS ##############################################################
################################################################################
# Save compiler and launcher paths if they are absolute (e.g. from presets or CLI)
# to prevent conan_toolchain.cmake from overwriting them with relative names.
set(_ULIB_SAVE_CC "${CMAKE_C_COMPILER}")
set(_ULIB_SAVE_CXX "${CMAKE_CXX_COMPILER}")
set(_ULIB_SAVE_CC_LAUNCHER "${CMAKE_C_COMPILER_LAUNCHER}")
set(_ULIB_SAVE_CXX_LAUNCHER "${CMAKE_CXX_COMPILER_LAUNCHER}")
if(EXISTS "${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
include("${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
endif()
if(_ULIB_SAVE_CC AND IS_ABSOLUTE "${_ULIB_SAVE_CC}")
set(CMAKE_C_COMPILER "${_ULIB_SAVE_CC}" CACHE FILEPATH "C compiler" FORCE)
endif()
if(_ULIB_SAVE_CXX AND IS_ABSOLUTE "${_ULIB_SAVE_CXX}")
set(CMAKE_CXX_COMPILER "${_ULIB_SAVE_CXX}" CACHE FILEPATH "C++ compiler" FORCE)
endif()
if(_ULIB_SAVE_CC_LAUNCHER AND IS_ABSOLUTE "${_ULIB_SAVE_CC_LAUNCHER}")
set(CMAKE_C_COMPILER_LAUNCHER "${_ULIB_SAVE_CC_LAUNCHER}" CACHE FILEPATH "C compiler launcher" FORCE)
endif()
if(_ULIB_SAVE_CXX_LAUNCHER AND IS_ABSOLUTE "${_ULIB_SAVE_CXX_LAUNCHER}")
set(CMAKE_CXX_COMPILER_LAUNCHER "${_ULIB_SAVE_CXX_LAUNCHER}" CACHE FILEPATH "C++ compiler launcher" FORCE)
endif()
cmake_minimum_required (VERSION 3.26)
set(QT_NO_VERSION_CHECK TRUE)

57
CMakePresets.json
View File

@@ -2,64 +2,37 @@
"version": 8,
"configurePresets": [
{
"name": "gcc-make",
"name": "andrea",
"displayName": "Custom configure preset",
"description": "Sets Makefile generator, build and install directory",
"generator": "Unix Makefiles",
"binaryDir": "${sourceDir}/build/${presetName}",
"description": "Sets Ninja generator, build and install directory",
"generator": "Ninja",
"binaryDir": "${sourceDir}/out/build/${presetName}",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
}
},
{
"name": "clang-ninja",
"displayName": "Ninja + clang + ccache",
"name": "fast",
"displayName": "Fast build: Ninja + clang + ccache",
"description": "Uses Ninja generator, clang/lld compiler, and ccache",
"generator": "Ninja",
"binaryDir": "${sourceDir}/build/${presetName}",
"binaryDir": "${sourceDir}/build",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
"CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
"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": "/home/share/micromamba/envs/uLib/bin/ccache",
"CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache"
"CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
"CMAKE_C_COMPILER_LAUNCHER": "ccache"
}
},
{
"name": "clang-make",
"displayName": "Makefile + clang + ccache",
"description": "Uses Makefile generator, clang/lld compiler, and ccache",
"generator": "Unix Makefiles",
"binaryDir": "${sourceDir}/build/${presetName}",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
"CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
"CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
"CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
"CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
"CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache"
}
},
{
"name": "cuda",
"displayName": "Makefile + clang + ccache",
"description": "Uses Makefile generator, clang/lld compiler, and ccache",
"generator": "Unix Makefiles",
"binaryDir": "${sourceDir}/build/${presetName}",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
"CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
"CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
"CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
"CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
"CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
"USE_CUDA": "ON"
}
"name": "mutom",
"description": "",
"displayName": "",
"inherits": []
}
]
}

8
README.md
View File

@@ -88,9 +88,11 @@ micromamba install -n uLib -y clang clangxx lld -c conda-forge
Then build using the `fast` profile:
```bash
conan install . --output-folder=build/clang-ninja --build=missing --profile=fast
cmake --preset clang-ninja
cmake --build build/clang-ninja -j$(nproc)
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:

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

@@ -38,8 +38,8 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
});
// Connect existing objects
for (const auto& obj : m_rootContext->GetObjects()) {
uLib::Object::connect(obj.get(), &uLib::Object::Updated, refresh);
for (auto* obj : m_rootContext->GetObjects()) {
uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
}
}
endResetModel();
@@ -148,6 +148,7 @@ 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));
@@ -229,8 +230,8 @@ bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, in
[&findAndRemoveRecursive](uLib::Object* current, uLib::Object* target) {
if (auto ctx = current->GetChildren()) {
ctx->RemoveObject(target);
for (const auto& obj : ctx->GetObjects()) {
findAndRemoveRecursive(obj.get(), target);
for (auto* obj : ctx->GetObjects()) {
findAndRemoveRecursive(obj, target);
}
}
};
@@ -244,12 +245,12 @@ bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, in
// 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 (const auto& child : ctx->GetObjects()) {
if (child.get() == target) return true;
if (isDescendant(child.get(), target)) return true;
}
}
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;

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

@@ -10,7 +10,6 @@
#include <QList>
#include <QShortcut>
#include <QItemSelectionModel>
#include <functional>
ContextPanel::ContextPanel(QWidget* parent)
: QWidget(parent)
@@ -58,8 +57,6 @@ ContextPanel::ContextPanel(QWidget* parent)
m_splitter->setSizes(sizes);
m_layout->addWidget(m_splitter);
connect(m_propertiesPanel, &PropertiesPanel::propertyUpdated, this, &ContextPanel::propertyUpdated);
connect(m_treeView->selectionModel(), &QItemSelectionModel::selectionChanged,
this, &ContextPanel::onSelectionChanged);
@@ -90,10 +87,6 @@ void ContextPanel::setContext(uLib::ObjectsContext* context) {
m_treeView->expandAll();
}
void ContextPanel::setPropertyContext(uLib::ObjectsContext* context) {
m_propertiesPanel->setContext(context);
}
void ContextPanel::onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected) {
uLib::Object* target = nullptr;
if (!selected.indexes().isEmpty()) {
@@ -110,34 +103,15 @@ void ContextPanel::selectObject(uLib::Object* obj) {
return;
}
// Recursive search helper
std::function<QModelIndex(const QModelIndex&)> findIdx = [&](const QModelIndex& parent) -> QModelIndex {
for (int i = 0; i < m_model->rowCount(parent); ++i) {
QModelIndex idx = m_model->index(i, 0, parent);
if (idx.internalPointer() == obj) return idx;
if (m_model->rowCount(idx) > 0) {
QModelIndex childIdx = findIdx(idx);
if (childIdx.isValid()) return childIdx;
}
for (int i = 0; i < m_model->rowCount(); ++i) {
QModelIndex idx = m_model->index(i, 0);
if (idx.internalPointer() == obj) {
QSignalBlocker blocker(m_treeView->selectionModel());
m_treeView->selectionModel()->select(idx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
m_treeView->scrollTo(idx);
m_propertiesPanel->setObject(obj); // Explicitly update properties too
return;
}
return QModelIndex();
};
QModelIndex targetIdx = findIdx(QModelIndex());
if (targetIdx.isValid()) {
QSignalBlocker blocker(m_treeView->selectionModel());
// Expand parents so the selection is visible
QModelIndex p = targetIdx.parent();
while (p.isValid()) {
m_treeView->expand(p);
p = p.parent();
}
m_treeView->selectionModel()->select(targetIdx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
m_treeView->scrollTo(targetIdx);
m_propertiesPanel->setObject(obj);
}
}

2
app/gcompose/src/ContextPanel.h
View File

@@ -20,13 +20,11 @@ public:
~ContextPanel();
void setContext(uLib::ObjectsContext* context);
void setPropertyContext(uLib::ObjectsContext* context);
void selectObject(uLib::Object* obj);
void clearSelection();
signals:
void objectSelected(uLib::Object* obj);
void propertyUpdated();
private slots:
void onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);

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

@@ -6,8 +6,6 @@
#include "Core/ObjectsContext.h"
#include "Vtk/vtkObjectsContext.h"
#include "Vtk/vtkQViewport.h"
#include "Vtk/vtkViewportProperties.h"
#include <Vtk/uLibVtkInterface.h>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QSplitter>
@@ -24,7 +22,7 @@
#include "PreferencesDialog.h"
#include "Settings.h"
MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr), m_viewportProps(nullptr) {
MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr) {
this->setObjectName("MainPanel");
this->setAttribute(Qt::WA_StyledBackground);
auto* mainLayout = new QVBoxLayout(this);
@@ -100,13 +98,6 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
m_firstPane->setObject(obj);
}
});
connect(m_contextPanel, &ContextPanel::propertyUpdated, [this](){
auto viewports = this->findChildren<uLib::Vtk::QViewport*>();
for (auto* vp : viewports) {
vp->Render();
}
});
// Set initial sizes: Context(250), Viewport(600), Properties(250)
QList<int> sizes;
@@ -127,10 +118,7 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
void MainPanel::setContext(uLib::ObjectsContext* context) {
m_context = context;
m_contextPanel->setContext(context);
// Propagate context to all panels for reference property dropdowns
m_contextPanel->setPropertyContext(context);
m_firstPane->setContext(context);
if (m_mainVtkContext) {
if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
viewport->RemoveProp3D(*m_mainVtkContext);
@@ -182,8 +170,8 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
// Add any prop3ds that were created during m_mainVtkContext's construction to all panes
auto panes = this->findChildren<ViewportPane*>();
for (const auto& obj : context->GetObjects()) {
if (auto* p = m_mainVtkContext->GetProp3D(obj.get())) {
for (auto* obj : context->GetObjects()) {
if (auto* p = m_mainVtkContext->GetProp3D(obj)) {
for (auto* pane : panes) {
if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
vp->AddProp3D(*p);
@@ -256,21 +244,15 @@ void MainPanel::onExit() {
void MainPanel::onPreferences() {
uLib::Qt::PreferencesDialog dlg(this);
if (dlg.exec() == QDialog::Accepted) {
// Apply theme and GUI font
// Apply theme
auto theme = uLib::Qt::Settings::Instance().GetTheme();
auto guiFont = uLib::Qt::Settings::Instance().GetGuiFont();
StyleManager::applyStyle(qApp, theme == uLib::Qt::Settings::Dark ? "dark" : "bright", guiFont);
StyleManager::applyStyle(qApp, theme == uLib::Qt::Settings::Dark ? "dark" : "bright");
// Apply rendering and font preferences to all viewports
// Apply rendering preference to all viewports
bool throttled = uLib::Qt::Settings::Instance().GetThrottledRendering();
auto font = uLib::Qt::Settings::Instance().GetFont();
auto fontColor = uLib::Qt::Settings::Instance().GetFontColor();
auto viewports = this->findChildren<uLib::Vtk::QViewport*>();
for (auto* vp : viewports) {
vp->SetThrottledRendering(throttled);
vp->SetFont(font);
vp->SetFontColor(fontColor);
vp->Render();
}
}

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

@@ -12,7 +12,6 @@ namespace uLib {
class ObjectsContext;
namespace Vtk {
class ObjectsContext;
class ViewportProperties;
}
}
@@ -41,7 +40,6 @@ private:
ContextPanel* m_contextPanel;
uLib::ObjectsContext* m_context;
uLib::Vtk::ObjectsContext* m_mainVtkContext;
uLib::Vtk::ViewportProperties* m_viewportProps;
};
#endif // MAINPANEL_H

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

@@ -5,8 +5,6 @@
#include <QPushButton>
#include <QLabel>
#include <QGroupBox>
#include <QColorDialog>
#include <QFormLayout>
namespace uLib {
namespace Qt {
@@ -66,77 +64,6 @@ PreferencesDialog::PreferencesDialog(QWidget* parent) : QDialog(parent) {
mainLayout->addWidget(unitsGroup);
// ── Font Configuration ──────────────────────────────────────────────────
auto* fontGroup = new QGroupBox("Viewport Font Configuration", this);
auto* fontLayout = new QFormLayout(fontGroup);
fontLayout->setLabelAlignment(::Qt::AlignRight);
FontConfig currentFont = Settings::Instance().GetFont();
m_currentFontColor = Settings::Instance().GetFontColor();
m_fontFamilies = new QComboBox(fontGroup);
m_fontFamilies->addItems({"Arial", "Courier", "Times"});
m_fontFamilies->setCurrentText(QString::fromStdString(currentFont.family));
m_fontSize = new QSpinBox(fontGroup);
m_fontSize->setRange(6, 72);
m_fontSize->setValue(currentFont.size);
m_fontBold = new QCheckBox("Bold", fontGroup);
m_fontBold->setChecked(currentFont.bold);
m_fontItalic = new QCheckBox("Italic", fontGroup);
m_fontItalic->setChecked(currentFont.italic);
m_fontColorBtn = new QPushButton(fontGroup);
m_fontColorBtn->setFixedWidth(60);
updateFontColorButton();
connect(m_fontColorBtn, &QPushButton::clicked, [this](){
QColor c = QColor::fromRgbF(m_currentFontColor.x(), m_currentFontColor.y(), m_currentFontColor.z());
QColor selected = QColorDialog::getColor(c, this, "Select Font Color");
if (selected.isValid()) {
m_currentFontColor = Vector3d(selected.redF(), selected.greenF(), selected.blueF());
updateFontColorButton();
}
});
fontLayout->addRow("Family:", m_fontFamilies);
fontLayout->addRow("Size:", m_fontSize);
fontLayout->addRow(m_fontBold);
fontLayout->addRow(m_fontItalic);
fontLayout->addRow("Color:", m_fontColorBtn);
mainLayout->addWidget(fontGroup);
// ── GUI Font Configuration ──────────────────────────────────────────────
auto* guiFontGroup = new QGroupBox("GUI Font Configuration", this);
auto* guiFontLayout = new QFormLayout(guiFontGroup);
guiFontLayout->setLabelAlignment(::Qt::AlignRight);
FontConfig currentGuiFont = Settings::Instance().GetGuiFont();
m_guiFontFamilies = new QComboBox(guiFontGroup);
m_guiFontFamilies->setEditable(true);
m_guiFontFamilies->addItems({"Inter", "Roboto", "Segoe UI", "Arial", "Ubuntu"});
m_guiFontFamilies->setCurrentText(QString::fromStdString(currentGuiFont.family));
m_guiFontSize = new QSpinBox(guiFontGroup);
m_guiFontSize->setRange(6, 48);
m_guiFontSize->setValue(currentGuiFont.size);
m_guiFontBold = new QCheckBox("Bold", guiFontGroup);
m_guiFontBold->setChecked(currentGuiFont.bold);
m_guiFontItalic = new QCheckBox("Italic", guiFontGroup);
m_guiFontItalic->setChecked(currentGuiFont.italic);
guiFontLayout->addRow("Family:", m_guiFontFamilies);
guiFontLayout->addRow("Size:", m_guiFontSize);
guiFontLayout->addRow(m_guiFontBold);
guiFontLayout->addRow(m_guiFontItalic);
mainLayout->addWidget(guiFontGroup);
mainLayout->addStretch();
// ── Buttons ─────────────────────────────────────────────────────────────
@@ -165,20 +92,8 @@ void PreferencesDialog::onAccept() {
Settings::Instance().SetPreferredUnit(pair.first, pair.second->currentText().toStdString());
}
FontConfig font(m_fontFamilies->currentText().toStdString(), m_fontSize->value(), m_fontBold->isChecked(), m_fontItalic->isChecked());
Settings::Instance().SetFont(font);
Settings::Instance().SetFontColor(m_currentFontColor);
FontConfig guiFont(m_guiFontFamilies->currentText().toStdString(), m_guiFontSize->value(), m_guiFontBold->isChecked(), m_guiFontItalic->isChecked());
Settings::Instance().SetGuiFont(guiFont);
accept();
}
void PreferencesDialog::updateFontColorButton() {
QColor c = QColor::fromRgbF(m_currentFontColor.x(), m_currentFontColor.y(), m_currentFontColor.z());
m_fontColorBtn->setStyleSheet(QString("background-color: %1; border: 1px solid #555; height: 18px;").arg(c.name()));
}
} // namespace Qt
} // namespace uLib

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

@@ -4,8 +4,6 @@
#include <QDialog>
#include <QCheckBox>
#include <QComboBox>
#include <QSpinBox>
#include <QPushButton>
#include <map>
#include <string>
#include "Settings.h"
@@ -25,22 +23,6 @@ private:
QCheckBox* m_throttledRendering;
QComboBox* m_themeCombo;
std::map<Settings::Dimension, QComboBox*> m_unitCombos;
// Font Configuration
QComboBox* m_fontFamilies;
QSpinBox* m_fontSize;
QCheckBox* m_fontBold;
QCheckBox* m_fontItalic;
QPushButton* m_fontColorBtn;
Vector3d m_currentFontColor;
// GUI Font Configuration
QComboBox* m_guiFontFamilies;
QSpinBox* m_guiFontSize;
QCheckBox* m_guiFontBold;
QCheckBox* m_guiFontItalic;
void updateFontColorButton();
};
} // namespace Qt

8
app/gcompose/src/PropertiesPanel.cpp
View File

@@ -30,10 +30,6 @@ PropertiesPanel::PropertiesPanel(QWidget* parent) : QWidget(parent) {
// Editor
m_editor = new uLib::Qt::PropertyEditor(this);
m_layout->addWidget(m_editor, 1);
connect(m_editor, &uLib::Qt::PropertyEditor::propertyUpdated, [this](uLib::PropertyBase*){
emit propertyUpdated();
});
}
void PropertiesPanel::setObject(uLib::Object* obj) {
@@ -47,8 +43,4 @@ void PropertiesPanel::setObject(uLib::Object* obj) {
m_editor->setObject(obj);
}
void PropertiesPanel::setContext(uLib::ObjectsContext* context) {
m_editor->setContext(context);
}
PropertiesPanel::~PropertiesPanel() {}

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

@@ -5,7 +5,6 @@
namespace uLib {
class Object;
class ObjectsContext;
namespace Qt { class PropertyEditor; }
}
@@ -24,12 +23,6 @@ public:
/** @brief Sets the object to be inspected. */
void setObject(uLib::Object* obj);
/** @brief Sets the context for reference property dropdowns. */
void setContext(uLib::ObjectsContext* context);
signals:
void propertyUpdated();
private:
QVBoxLayout* m_layout;

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

@@ -11,9 +11,7 @@
#include <QColorDialog>
#include <QFrame>
#include <QSlider>
#include <QFontDialog>
#include "Settings.h"
#include "Core/ObjectsContext.h"
namespace uLib {
namespace Qt {
@@ -153,7 +151,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); emit updated(); });
connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
m_Edit->setValue(m_Prop->Get());
});
@@ -171,7 +169,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); emit updated(); });
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_Edit->setValue((double)m_Prop->Get());
});
@@ -190,7 +188,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); emit updated(); });
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_Edit->setValue((double)m_Prop->Get());
});
@@ -201,7 +199,7 @@ BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
m_CheckBox = new QCheckBox(this);
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); emit updated(); } });
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](){
if (m_CheckBox->isChecked() != m_Prop->Get()) {
QSignalBlocker blocker(m_CheckBox);
@@ -224,7 +222,7 @@ RangePropertyWidget::RangePropertyWidget(Property<double>* prop, QWidget* parent
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); emit updated(); });
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();
@@ -246,7 +244,6 @@ void RangePropertyWidget::updateUi() {
void RangePropertyWidget::onSliderChanged(int val) {
double realVal = m_Prop->GetMin() + (val / 100.0) * (m_Prop->GetMax() - m_Prop->GetMin());
m_Prop->Set(realVal);
emit updated();
}
ColorPropertyWidget::ColorPropertyWidget(Property<Vector3d>* prop, QWidget* parent)
@@ -279,7 +276,6 @@ void ColorPropertyWidget::onClicked() {
QColor selected = QColorDialog::getColor(current, this, "Select Color");
if (selected.isValid()) {
m_Prop->Set(Vector3d(selected.redF(), selected.greenF(), selected.blueF()));
emit updated();
}
}
@@ -290,7 +286,7 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
m_Layout->addWidget(m_LineEdit, 1);
connect(m_LineEdit, &QLineEdit::editingFinished, [this](){
std::string val = m_LineEdit->text().toStdString();
if (m_Prop->Get() != val) { m_Prop->Set(val); emit updated(); }
if (m_Prop->Get() != val) m_Prop->Set(val);
});
m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::Updated, [this](){
if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
@@ -301,40 +297,6 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
}
StringPropertyWidget::~StringPropertyWidget() {}
FontPropertyWidget::FontPropertyWidget(Property<FontConfig>* prop, QWidget* parent)
: PropertyWidgetBase(prop, parent), m_Prop(prop) {
m_Button = new QPushButton(this);
m_Button->setMinimumWidth(100);
this->updateButtonText();
m_Layout->addWidget(m_Button, 1);
connect(m_Button, &QPushButton::clicked, this, &FontPropertyWidget::onClicked);
m_Connection = uLib::Object::connect(m_Prop, &Property<FontConfig>::Updated, [this](){
this->updateButtonText();
});
}
FontPropertyWidget::~FontPropertyWidget() {}
void FontPropertyWidget::updateButtonText() {
FontConfig f = m_Prop->Get();
m_Button->setText(QString::fromStdString(f.family) + " " + QString::number(f.size));
}
void FontPropertyWidget::onClicked() {
FontConfig current = m_Prop->Get();
QFont font(QString::fromStdString(current.family), current.size);
font.setBold(current.bold);
font.setItalic(current.italic);
bool ok;
QFont selected = QFontDialog::getFont(&ok, font, this, "Select Font");
if (ok) {
FontConfig newF(selected.family().toStdString(), selected.pointSize(), selected.bold(), selected.italic());
m_Prop->Set(newF);
emit updated();
}
}
class GroupHeaderWidget : public QWidget {
public:
GroupHeaderWidget(const QString& name, QWidget* parent = nullptr) : QWidget(parent) {
@@ -370,9 +332,8 @@ public:
// Get initial value
if (auto* p = dynamic_cast<Property<int>*>(prop)) {
m_Combo->setCurrentIndex(p->Get());
connect(m_Combo, &QComboBox::currentIndexChanged, [this, p](int index){
connect(m_Combo, &QComboBox::currentIndexChanged, [p](int index){
p->Set(index);
emit updated();
});
// Store connection in base m_Connection so it's auto-disconnected on destruction.
m_Connection = uLib::Object::connect(p, &Property<int>::Updated, [this, p](){
@@ -387,74 +348,7 @@ public:
}
};
////////////////////////////////////////////////////////////////////////////////
// ReferencePropertyWidget
ReferencePropertyWidget::ReferencePropertyWidget(ReferencePropertyBase* prop, ::uLib::ObjectsContext* context, QWidget* parent)
: PropertyWidgetBase(prop, parent), m_RefProp(prop), m_Context(context) {
m_Combo = new QComboBox(static_cast<QWidget*>(this));
m_Layout->addWidget(m_Combo, 1);
refreshCombo();
connect(m_Combo, &QComboBox::currentIndexChanged, this, &ReferencePropertyWidget::onComboChanged);
// Listen for property updates to refresh selected item
m_Connection = uLib::Object::connect(prop, &uLib::Object::Updated, [this](){
QSignalBlocker blocker(m_Combo);
refreshCombo();
});
// Listen for context changes to refresh the dropdown list
if (m_Context) {
m_ContextConnection = uLib::Object::connect(m_Context, &uLib::Object::Updated, [this](){
QSignalBlocker blocker(m_Combo);
refreshCombo();
});
}
}
ReferencePropertyWidget::~ReferencePropertyWidget() {
m_Connection.disconnect();
m_ContextConnection.disconnect();
}
void ReferencePropertyWidget::refreshCombo() {
m_Combo->clear();
m_Combo->addItem("(none)", QVariant::fromValue((quintptr)0));
int selectedIdx = 0;
Object* currentRef = m_RefProp->GetReferencedObject();
if (m_Context) {
const auto& objects = m_Context->GetObjects();
for (const auto& obj : objects) {
if (m_RefProp->IsCompatible(obj.get())) {
QString label = QString::fromStdString(obj->GetInstanceName());
if (label.isEmpty()) {
label = QString::fromStdString(std::string(obj->GetClassName()));
}
// Add index suffix if name is empty to disambiguate
m_Combo->addItem(label, QVariant::fromValue((quintptr)obj.get()));
if (obj.get() == currentRef) {
selectedIdx = m_Combo->count() - 1;
}
}
}
}
m_Combo->setCurrentIndex(selectedIdx);
}
void ReferencePropertyWidget::onComboChanged(int index) {
if (index < 0) return;
quintptr ptr = m_Combo->itemData(index).value<quintptr>();
Object* obj = reinterpret_cast<Object*>(ptr);
m_RefProp->SetReferencedObject(obj);
Q_EMIT updated();
}
////////////////////////////////////////////////////////////////////////////////
// PropertyEditor
PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr), m_Context(nullptr) {
PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr) {
m_MainLayout = new QVBoxLayout(this);
m_MainLayout->setContentsMargins(0, 0, 0, 0);
m_ScrollArea = new QScrollArea(this);
@@ -480,9 +374,6 @@ PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(null
registerFactory<std::string>([](PropertyBase* p, QWidget* parent){
return new StringPropertyWidget(static_cast<Property<std::string>*>(p), parent);
});
registerFactory<FontConfig>([](PropertyBase* p, QWidget* parent){
return new FontPropertyWidget(static_cast<Property<FontConfig>*>(p), parent);
});
// Register EnumProperty specifically (needs to check type since it holds Property<int> but is EnumProperty)
m_Factories[std::type_index(typeid(EnumProperty))] = [](PropertyBase* p, QWidget* parent) {
@@ -556,32 +447,21 @@ void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
// widget = new RangePropertyWidget<float>(pflt, m_Container);
}
} else {
// Priority 2: Check for reference properties (SmartPointer<T>)
if (auto* refProp = dynamic_cast<::uLib::ReferencePropertyBase*>(prop)) {
widget = static_cast<QWidget*>(new ReferencePropertyWidget(refProp, m_Context, m_Container));
} else {
// Priority 3: Standard factory lookup
// Priority 2: Standard factory lookup
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;
// 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->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
}
}
}
if (widget) {
if (auto* propWidget = qobject_cast<PropertyWidgetBase*>(widget)) {
connect(propWidget, &PropertyWidgetBase::updated, [this, prop](){
emit propertyUpdated(prop);
});
}
if (!groupName.empty()) {
// Indent grouped properties
widget->setContentsMargins(16, 0, 0, 0);

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

@@ -4,7 +4,6 @@
#include <QWidget>
class QPushButton;
class QSlider;
class QComboBox;
#include <QLabel>
#include <QHBoxLayout>
#include <QVBoxLayout>
@@ -18,12 +17,9 @@ class QComboBox;
#include "Core/Property.h"
#include "Core/Object.h"
#include "Core/Signal.h"
#include "Core/FontConfig.h"
#include "Math/Dense.h"
#include "Settings.h"
namespace uLib { class ObjectsContext; }
namespace uLib {
namespace Qt {
@@ -36,9 +32,6 @@ public:
virtual ~PropertyWidgetBase();
PropertyBase* getProperty() const { return m_BaseProperty; }
signals:
void updated();
protected:
PropertyBase* m_BaseProperty;
QHBoxLayout* m_Layout;
@@ -128,10 +121,7 @@ public:
connect(m_Edits[i], &UnitLineEdit::valueManualChanged, [this, i](double val){
VecT v = m_Prop->Get();
v(i) = (typename VecT::Scalar)val;
if (m_Prop->Get() != v) {
m_Prop->Set(v);
emit updated();
}
if (m_Prop->Get() != v) m_Prop->Set(v);
});
}
updateEdits();
@@ -201,53 +191,20 @@ private:
QLineEdit* m_LineEdit;
};
class FontPropertyWidget : public PropertyWidgetBase {
Q_OBJECT
public:
FontPropertyWidget(Property<FontConfig>* prop, QWidget* parent = nullptr);
virtual ~FontPropertyWidget();
private slots:
void onClicked();
private:
void updateButtonText();
Property<FontConfig>* m_Prop;
QPushButton* m_Button;
};
class ReferencePropertyWidget : public PropertyWidgetBase {
Q_OBJECT
public:
ReferencePropertyWidget(ReferencePropertyBase* prop, ::uLib::ObjectsContext* context, QWidget* parent = nullptr);
virtual ~ReferencePropertyWidget();
private slots:
void onComboChanged(int index);
private:
void refreshCombo();
ReferencePropertyBase* m_RefProp;
::uLib::ObjectsContext* m_Context;
QComboBox* m_Combo;
Connection m_ContextConnection;
};
class PropertyEditor : public QWidget {
Q_OBJECT
public:
PropertyEditor(QWidget* parent = nullptr);
virtual ~PropertyEditor();
void setObject(uLib::Object* obj, bool displayOnly = false);
void setContext(uLib::ObjectsContext* context) { m_Context = context; }
template<typename T>
void registerFactory(std::function<QWidget*(PropertyBase*, QWidget*)> factory) {
m_Factories[std::type_index(typeid(T))] = factory;
}
signals:
void propertyUpdated(PropertyBase* prop = nullptr);
private:
void clear();
uLib::Object* m_Object;
uLib::ObjectsContext* m_Context;
QVBoxLayout* m_MainLayout;
QScrollArea* m_ScrollArea;
QWidget* m_Container;

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

@@ -94,8 +94,8 @@ void QViewportPane::setObject(uLib::Object* obj) {
void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
if (m_viewport) {
m_viewport->parentWidget()->layout()->removeWidget(m_viewport);
delete m_viewport;
// Use deleteLater() instead of delete to avoid crashes during repaint cycles
m_viewport->deleteLater();
}
m_viewport = viewport;
m_titleLabel->setText(title);
@@ -105,21 +105,8 @@ 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");

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

@@ -4,8 +4,6 @@
#include <string>
#include <map>
#include "Math/Units.h"
#include "Core/FontConfig.h"
#include "Math/Dense.h"
namespace uLib {
namespace Qt {
@@ -77,23 +75,11 @@ public:
Theme GetTheme() const { return m_Theme; }
void SetTheme(Theme theme) { m_Theme = theme; }
FontConfig GetFont() const { return m_Font; }
void SetFont(const FontConfig& font) { m_Font = font; }
FontConfig GetGuiFont() const { return m_GuiFont; }
void SetGuiFont(const FontConfig& font) { m_GuiFont = font; }
Vector3d GetFontColor() const { return m_FontColor; }
void SetFontColor(const Vector3d& color) { m_FontColor = color; }
private:
Settings() : m_ThrottledRendering(true), m_Theme(Dark), m_Font("Arial", 10), m_GuiFont("Inter", 9), m_FontColor(1.0, 1.0, 1.0) {}
Settings() : m_ThrottledRendering(true), m_Theme(Dark) {}
std::map<Dimension, std::string> m_PreferredUnits;
bool m_ThrottledRendering;
Theme m_Theme;
FontConfig m_Font;
FontConfig m_GuiFont;
Vector3d m_FontColor;
};
} // namespace Qt

50
app/gcompose/src/StyleManager.cpp
View File

@@ -1,15 +1,11 @@
#include "StyleManager.h"
#include <QApplication>
#include "Core/FontConfig.h"
static const QString DARK_THEME = R"(
QWidget#MenuPanel { background-color: #2b2b2b; border-bottom: 1px solid #111; }
QLabel#LogoLabel { font-weight: bold; color: #0078d7; font-size: 14px; letter-spacing: 1px; }
QPushButton#MenuButton { background: transparent; color: #ccc; border: none; padding: 5px 10px; }
QPushButton#MenuButton:hover { background: #3c3c3c; color: white; border-radius: 4px; }
QPushButton { background-color: #3e3e42; color: white; border: 1px solid #555; padding: 4px 12px; border-radius: 2px; }
QPushButton:hover { background-color: #505050; border-color: #0078d7; }
QPushButton:pressed { background-color: #0078d7; }
QWidget#PaneTitleBar { background-color: #333; color: white; border-bottom: 2px solid #222; }
QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #ccc; }
@@ -27,11 +23,8 @@ QScrollArea > QWidget > QWidget { background: transparent; }
/* Property Widgets Styling */
QLabel { color: #cccccc; }
QDoubleSpinBox, QSpinBox, QLineEdit, QComboBox { background: #3c3c3c; color: #f1f1f1; border: 1px solid #3e3e42; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus, QComboBox:focus { border-color: #0078d7; }
QComboBox::drop-down { border-left-width: 1px; border-left-color: #3e3e42; border-left-style: solid; width: 20px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; }
QComboBox::down-arrow { image: none; border: 5px solid transparent; border-top-color: #ccc; margin-top: 5px; }
QAbstractItemView { background-color: #2b2b2b; color: white; border: 1px solid #3e3e42; selection-background-color: #0078d7; outline: 0; }
QDoubleSpinBox, QSpinBox, QLineEdit { background: #3c3c3c; color: #f1f1f1; border: 1px solid #3e3e42; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
QCheckBox { color: #cccccc; spacing: 5px; }
QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #3e3e42; background: #333337; border-radius: 2px; }
QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
@@ -49,11 +42,6 @@ QScrollBar:vertical { background: #1e1e1e; width: 12px; margin: 0px; }
QScrollBar::handle:vertical { background: #3e3e42; min-height: 20px; border-radius: 6px; margin: 2px; }
QScrollBar::handle:vertical:hover { background: #505050; }
QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
/* Dialogs & Preferences */
QDialog { background-color: #252526; color: #f1f1f1; }
QGroupBox { font-weight: bold; color: #0078d7; border: 1px solid #3e3e42; margin-top: 1.1em; padding-top: 0.5em; border-radius: 4px; }
QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top left; padding: 0 3px; left: 10px; }
)";
static const QString BRIGHT_THEME = R"(
@@ -61,9 +49,6 @@ QWidget#MenuPanel { background-color: #f3f3f3; border-bottom: 1px solid #ccc; }
QLabel#LogoLabel { font-weight: bold; color: #005a9e; font-size: 14px; letter-spacing: 1px; }
QPushButton#MenuButton { background: transparent; color: #333; border: none; padding: 5px 10px; }
QPushButton#MenuButton:hover { background: #e5e5e5; color: black; border-radius: 4px; }
QPushButton { background-color: #ffffff; color: #333; border: 1px solid #cccccc; padding: 4px 12px; border-radius: 2px; }
QPushButton:hover { background-color: #f2f2f2; border-color: #0078d7; }
QPushButton:pressed { background-color: #0078d7; color: white; }
QWidget#PaneTitleBar { background-color: #eeeeee; color: black; border-bottom: 2px solid #ddd; }
QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #666; }
@@ -81,11 +66,8 @@ QScrollArea > QWidget > QWidget { background: transparent; }
/* Property Widgets Styling */
QLabel { color: #333333; }
QDoubleSpinBox, QSpinBox, QLineEdit, QComboBox { background: #ffffff; color: #333333; border: 1px solid #cccccc; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus, QComboBox:focus { border-color: #0078d7; }
QComboBox::drop-down { border-left-width: 1px; border-left-color: #cccccc; border-left-style: solid; width: 20px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; }
QComboBox::down-arrow { image: none; border: 5px solid transparent; border-top-color: #666; margin-top: 5px; }
QAbstractItemView { background-color: #ffffff; color: #333; border: 1px solid #cccccc; selection-background-color: #0078d7; outline: 0; }
QDoubleSpinBox, QSpinBox, QLineEdit { background: #ffffff; color: #333333; border: 1px solid #cccccc; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
QCheckBox { color: #333333; spacing: 5px; }
QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #cccccc; background: #ffffff; border-radius: 2px; }
QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
@@ -103,26 +85,14 @@ QScrollBar:vertical { background: #ffffff; width: 12px; margin: 0px; }
QScrollBar::handle:vertical { background: #cccccc; min-height: 20px; border-radius: 6px; margin: 2px; }
QScrollBar::handle:vertical:hover { background: #aaaaaa; }
QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
/* Dialogs & Preferences */
QDialog { background-color: #f3f3f3; color: #333; }
QGroupBox { font-weight: bold; color: #005a9e; border: 1px solid #cccccc; margin-top: 1.1em; padding-top: 0.5em; border-radius: 4px; }
QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top left; padding: 0 3px; left: 10px; }
)";
void StyleManager::applyStyle(QApplication* app, const QString& themeName, const uLib::FontConfig& fontCfg) {
void StyleManager::applyStyle(QApplication* app, const QString& themeName) {
if (!app) return;
QString baseStyle = (themeName == "bright") ? BRIGHT_THEME : DARK_THEME;
QString fontStyle = QString(
"QWidget { font-family: '%1'; font-size: %2pt; }\n"
).arg(QString::fromStdString(fontCfg.family))
.arg(fontCfg.size);
// If bold/italic are needed globally
if (fontCfg.bold) fontStyle += "QWidget { font-weight: bold; }\n";
if (fontCfg.italic) fontStyle += "QWidget { font-style: italic; }\n";
app->setStyleSheet(fontStyle + baseStyle);
if (themeName == "bright") {
app->setStyleSheet(BRIGHT_THEME);
} else {
app->setStyleSheet(DARK_THEME); // default
}
}

4
app/gcompose/src/StyleManager.h
View File

@@ -5,11 +5,9 @@
class QApplication;
namespace uLib { class FontConfig; }
class StyleManager {
public:
static void applyStyle(QApplication* app, const QString& themeName, const uLib::FontConfig& font);
static void applyStyle(QApplication* app, const QString& themeName);
};
#endif // STYLEMANAGER_H

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

@@ -113,13 +113,9 @@ void ViewportPane::setObject(uLib::Object* obj) {
}
}
void ViewportPane::setContext(uLib::ObjectsContext* context) {
m_displayEditor->setContext(context);
}
void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
if (m_viewport) {
delete m_viewport;
m_viewport->deleteLater();
}
m_viewport = viewport;
m_titleLabel->setText(title);
@@ -129,10 +125,6 @@ void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
m_areaSplitter->setStretchFactor(0, 1);
}
uLib::Vtk::Viewport* ViewportPane::viewport() const {
return dynamic_cast<uLib::Vtk::Viewport*>(m_viewport);
}
void ViewportPane::addVtkViewport() {
auto* viewport = new uLib::Vtk::QViewport(this);
setViewport(viewport, "VTK Viewport");

6
app/gcompose/src/ViewportPane.h
View File

@@ -7,9 +7,7 @@
namespace uLib {
class Object;
class ObjectsContext;
namespace Qt { class PropertyEditor; }
namespace Vtk { class Viewport; }
}
class QSplitter;
@@ -26,13 +24,9 @@ public:
void addRootCanvas();
QWidget* currentViewport() const { return m_viewport; }
uLib::Vtk::Viewport* viewport() const;
/** @brief Update the display properties for the given object. */
void setObject(uLib::Object* obj);
/** @brief Sets the context for reference property dropdowns. */
void setContext(uLib::ObjectsContext* context);
private slots:
void onCloseRequested();

6
app/gcompose/src/main.cpp
View File

@@ -3,8 +3,6 @@
#include "MainPanel.h"
#include "ViewportPane.h"
#include "StyleManager.h"
#include "Settings.h"
#include "Core/FontConfig.h"
#include "Math/ContainerBox.h"
#include <HEP/Geant/Scene.h>
@@ -31,9 +29,7 @@ using namespace uLib::literals;
int main(int argc, char** argv) {
QApplication app(argc, argv);
auto theme = uLib::Qt::Settings::Instance().GetTheme();
auto initialGuiFont = uLib::Qt::Settings::Instance().GetGuiFont();
StyleManager::applyStyle(&app, theme == uLib::Qt::Settings::Dark ? "dark" : "bright", initialGuiFont);
StyleManager::applyStyle(&app, "dark");
std::cout << "Starting gcompose Qt application..." << std::endl;
// ContainerBox world_box(Vector3f(1, 1, 1));

37
build.log
View File

@@ -1,36 +1 @@
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'
ninja: error: loading 'build.ninja': No such file or directory

217
cmake_output.log
View File

@@ -1,217 +0,0 @@
-- Using Conan toolchain: /home/rigoni/devel/cmt/uLib/build/clang-make/conan_toolchain.cmake
-- Conan toolchain: Defining architecture flag: -m64
-- Conan toolchain: Defining libcxx as C++ flags: -stdlib=libstdc++
-- Conan toolchain: C++ Standard 17 with extensions ON
-- The C compiler identification is Clang 21.1.0
-- The CXX compiler identification is Clang 21.1.0
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working C compiler: /home/share/micromamba/envs/uLib/bin/clang - skipped
-- Detecting C compile features
-- Detecting C compile features - done
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: /home/share/micromamba/envs/uLib/bin/clang++ - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Project name = uLib
-- Package name = mutom-0.7
-- Package version = 0.7
-- Module path = /home/rigoni/devel/cmt/uLib/CMake;/home/rigoni/devel/cmt/uLib/build/clang-make
-- CMAKE_PREFIX_PATH is /home/rigoni/devel/cmt/uLib/build/clang-make
-- Conan: Component target declared 'hdf5::hdf5'
-- Conan: Component target declared 'hdf5::hdf5_cpp'
-- Conan: Component target declared 'hdf5::hdf5_hl'
-- Conan: Component target declared 'hdf5::hdf5_hl_cpp'
-- Conan: Target declared 'HDF5::HDF5'
-- Conan: Target declared 'ZLIB::ZLIB'
-- Conan: Including build module from '/home/rigoni/.conan2/p/b/hdf509daaae89dd98/p/lib/cmake/conan-official-hdf5-variables.cmake'
-- Conan: Component target declared 'Boost::diagnostic_definitions'
-- Conan: Component target declared 'Boost::disable_autolinking'
-- Conan: Component target declared 'Boost::dynamic_linking'
-- Conan: Component target declared 'Boost::headers'
-- Conan: Component target declared 'Boost::boost'
-- Conan: Component target declared 'boost::_libboost'
-- Conan: Component target declared 'Boost::atomic'
-- Conan: Component target declared 'Boost::charconv'
-- Conan: Component target declared 'Boost::container'
-- Conan: Component target declared 'Boost::context'
-- Conan: Component target declared 'Boost::date_time'
-- Conan: Component target declared 'Boost::exception'
-- Conan: Component target declared 'Boost::math'
-- Conan: Component target declared 'Boost::program_options'
-- Conan: Component target declared 'Boost::regex'
-- Conan: Component target declared 'Boost::serialization'
-- Conan: Component target declared 'Boost::stacktrace'
-- Conan: Component target declared 'Boost::system'
-- Conan: Component target declared 'Boost::timer'
-- Conan: Component target declared 'Boost::chrono'
-- Conan: Component target declared 'Boost::coroutine'
-- Conan: Component target declared 'Boost::filesystem'
-- Conan: Component target declared 'Boost::json'
-- Conan: Component target declared 'Boost::math_c99'
-- Conan: Component target declared 'Boost::math_c99f'
-- Conan: Component target declared 'Boost::math_c99l'
-- Conan: Component target declared 'Boost::math_tr1'
-- Conan: Component target declared 'Boost::math_tr1f'
-- Conan: Component target declared 'Boost::math_tr1l'
-- Conan: Component target declared 'Boost::random'
-- Conan: Component target declared 'Boost::stacktrace_addr2line'
-- Conan: Component target declared 'Boost::stacktrace_backtrace'
-- Conan: Component target declared 'Boost::stacktrace_basic'
-- Conan: Component target declared 'Boost::stacktrace_from_exception'
-- Conan: Component target declared 'Boost::stacktrace_noop'
-- Conan: Component target declared 'Boost::test'
-- Conan: Component target declared 'Boost::url'
-- Conan: Component target declared 'Boost::wserialization'
-- Conan: Component target declared 'Boost::fiber'
-- Conan: Component target declared 'Boost::graph'
-- Conan: Component target declared 'Boost::iostreams'
-- Conan: Component target declared 'Boost::nowide'
-- Conan: Component target declared 'Boost::prg_exec_monitor'
-- Conan: Component target declared 'Boost::process'
-- Conan: Component target declared 'Boost::test_exec_monitor'
-- Conan: Component target declared 'Boost::thread'
-- Conan: Component target declared 'Boost::wave'
-- Conan: Component target declared 'Boost::contract'
-- Conan: Component target declared 'Boost::fiber_numa'
-- Conan: Component target declared 'Boost::locale'
-- Conan: Component target declared 'Boost::log'
-- Conan: Component target declared 'Boost::type_erasure'
-- Conan: Component target declared 'Boost::unit_test_framework'
-- Conan: Component target declared 'Boost::log_setup'
-- Conan: Target declared 'boost::boost'
-- Conan: Target declared 'BZip2::BZip2'
-- Conan: Including build module from '/home/rigoni/.conan2/p/b/bzip2b5764e08a4f7d/p/lib/cmake/conan-official-bzip2-variables.cmake'
-- Conan: Target declared 'libbacktrace::libbacktrace'
-- Found OpenMP_C: -fopenmp=libomp (found version "5.1")
-- Found OpenMP_CXX: -fopenmp=libomp (found version "5.1")
-- Found OpenMP: TRUE (found version "5.1")
-- Found nlohmann_json: /home/share/micromamba/envs/uLib/share/cmake/nlohmann_json/nlohmann_jsonConfig.cmake (found suitable version "3.12.0", minimum required is "3.12.0")
-- Found Vdt: /home/share/micromamba/envs/uLib/include (found version "0.4")
-- Warning: Standard CMAKE_CXX_STANDARD value defined in conan_toolchain.cmake to 17 has been modified to 20 by /home/share/micromamba/envs/uLib/cmake/ROOTUseFile.cmake
-- Found Python3: /home/share/micromamba/envs/uLib/bin/python3.12 (found suitable version "3.12.13", minimum required is "3.12") found components: Interpreter Development.Module Development.Embed
-- Found nlohmann_json: /home/share/micromamba/envs/uLib/share/cmake/nlohmann_json/nlohmann_jsonConfig.cmake (found version "3.12.0")
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Success
-- Found Threads: TRUE
-- Performing Test HAVE_STDATOMIC
-- Performing Test HAVE_STDATOMIC - Success
-- Found WrapAtomic: TRUE
-- Found OpenGL: /home/share/micromamba/envs/uLib/lib/libOpenGL.so
-- Found WrapOpenGL: TRUE
-- Could NOT find WrapVulkanHeaders (missing: Vulkan_INCLUDE_DIR)
-- Found X11: /home/share/micromamba/envs/uLib/include
-- Looking for XOpenDisplay in /home/share/micromamba/envs/uLib/lib/libX11.so;/home/share/micromamba/envs/uLib/lib/libXext.so
-- Looking for XOpenDisplay in /home/share/micromamba/envs/uLib/lib/libX11.so;/home/share/micromamba/envs/uLib/lib/libXext.so - found
-- Looking for gethostbyname
-- Looking for gethostbyname - found
-- Looking for connect
-- Looking for connect - found
-- Looking for remove
-- Looking for remove - found
-- Looking for shmat
-- Looking for shmat - found
-- Looking for IceConnectionNumber in ICE
-- Looking for IceConnectionNumber in ICE - found
-- Performing Test Iconv_IS_BUILT_IN
-- Performing Test Iconv_IS_BUILT_IN - Failed
-- Found Iconv: /home/share/micromamba/envs/uLib/lib/libiconv.so (found version "1.18")
-- Found ICU: /home/share/micromamba/envs/uLib/include (found version "75.1") found components: data i18n uc
-- Looking for lzma_auto_decoder in /home/share/micromamba/envs/uLib/lib/liblzma.so
-- Looking for lzma_auto_decoder in /home/share/micromamba/envs/uLib/lib/liblzma.so - found
-- Looking for lzma_easy_encoder in /home/share/micromamba/envs/uLib/lib/liblzma.so
-- Looking for lzma_easy_encoder in /home/share/micromamba/envs/uLib/lib/liblzma.so - found
-- Looking for lzma_lzma_preset in /home/share/micromamba/envs/uLib/lib/liblzma.so
-- Looking for lzma_lzma_preset in /home/share/micromamba/envs/uLib/lib/liblzma.so - found
-- Found LibLZMA: /home/share/micromamba/envs/uLib/lib/liblzma.so (found version "5.8.2")
-- Conan: Including build module from '/home/rigoni/.conan2/p/b/hdf509daaae89dd98/p/lib/cmake/conan-official-hdf5-variables.cmake'
-- Found utf8cpp: /home/share/micromamba/envs/uLib/include
-- Found THEORA: /home/share/micromamba/envs/uLib/lib/libtheora.so
-- Found OGG: /home/share/micromamba/envs/uLib/lib/libogg.so
-- Found NetCDF: /home/share/micromamba/envs/uLib/include (found version "4.9.2")
-- Found JsonCpp: /home/share/micromamba/envs/uLib/lib/libjsoncpp.so (found suitable version "1.9.6", minimum required is "0.7.0")
-- Found PNG: /home/share/micromamba/envs/uLib/lib/libpng.so (found version "1.6.56")
-- Found GL2PS: /home/share/micromamba/envs/uLib/lib/libgl2ps.so (found suitable version "1.4.2", minimum required is "1.4.2")
-- Found LibPROJ: /home/share/micromamba/envs/uLib/lib/libproj.so (found version "9.6.2")
-- Found SQLite3: /home/share/micromamba/envs/uLib/lib/libsqlite3.so (found version "3.52.0")
-- Could NOT find WrapVulkanHeaders (missing: Vulkan_INCLUDE_DIR)
-- Found LZ4: /home/share/micromamba/envs/uLib/lib/liblz4.so (found version "1.10.0")
-- Found LZMA: /home/share/micromamba/envs/uLib/lib/liblzma.so (found version "5.8.2")
-- Found JPEG: /home/share/micromamba/envs/uLib/lib/libjpeg.so (found version "80")
-- Found TIFF: /home/share/micromamba/envs/uLib/lib/libtiff.so (found version "4.7.1")
-- Could NOT find freetype (missing: freetype_DIR)
-- Found Freetype: /home/share/micromamba/envs/uLib/lib/libfreetype.so (found version "2.14.3")
-- Performing Test HAS_FLTO_THIN
-- Performing Test HAS_FLTO_THIN - Failed
-- Performing Test HAS_FLTO_AUTO
-- Performing Test HAS_FLTO_AUTO - Failed
-- Performing Test HAS_FLTO
-- Performing Test HAS_FLTO - Failed
-- Found pybind11: /home/share/micromamba/envs/uLib/include (found version "3.0.3")
-- Could NOT find freetype (missing: freetype_DIR)
CMake Deprecation Warning at /home/share/micromamba/envs/uLib/lib/cmake/Geant4/PTL/PTLConfig.cmake:30 (cmake_minimum_required):
Compatibility with CMake < 3.10 will be removed from a future version of
CMake.
Update the VERSION argument <min> value. Or, use the <min>...<max> syntax
to tell CMake that the project requires at least <min> but has been updated
to work with policies introduced by <max> or earlier.
Call Stack (most recent call first):
/home/share/micromamba/envs/uLib/share/cmake-4.2/Modules/CMakeFindDependencyMacro.cmake:93 (find_package)
/home/share/micromamba/envs/uLib/share/cmake-4.2/Modules/CMakeFindDependencyMacro.cmake:125 (__find_dependency_common)
/home/share/micromamba/envs/uLib/lib/cmake/Geant4/Geant4Config.cmake:286 (find_dependency)
CMakeLists.txt:194 (find_package)
-- Found XercesC: /home/share/micromamba/envs/uLib/lib/libxerces-c.so (found suitable version "3.2.5", minimum required is "3.2.5")
-- Found Freetype: /home/share/micromamba/envs/uLib/lib/libfreetype.so (found suitable version "2.14.3", minimum required is "2.12.1")
-- Found Geant4: /home/share/micromamba/envs/uLib/lib/cmake/Geant4/Geant4Config.cmake (found version "11.2.2")
-- Geant4 libs: Geant4::G4Tree;Geant4::G4FR;Geant4::G4GMocren;Geant4::G4visHepRep;Geant4::G4RayTracer;Geant4::G4VRML;Geant4::G4ToolsSG;Geant4::G4vis_management;Geant4::G4modeling;Geant4::G4interfaces;Geant4::G4mctruth;Geant4::G4geomtext;Geant4::G4gdml;Geant4::G4analysis;Geant4::G4error_propagation;Geant4::G4readout;Geant4::G4physicslists;Geant4::G4run;Geant4::G4event;Geant4::G4tracking;Geant4::G4parmodels;Geant4::G4processes;Geant4::G4digits_hits;Geant4::G4track;Geant4::G4particles;Geant4::G4geometry;Geant4::G4materials;Geant4::G4graphics_reps;Geant4::G4intercoms;Geant4::G4global;Geant4::G4tools;Geant4::G4ptl
-- Looking for include file inittypes.h
-- Looking for include file inittypes.h - not found
-- Looking for include file stdbool.h
-- Looking for include file stdbool.h - not found
-- Looking for include file stdint.h
-- Looking for include file stdint.h - not found
-- Looking for include file stdlib.h
-- Looking for include file stdlib.h - not found
-- Looking for include file dlfcn.h
-- Looking for include file dlfcn.h - not found
-- Looking for include file malloc.h
-- Looking for include file malloc.h - not found
-- Looking for malloc
-- Looking for malloc - not found
-- Looking for include file memory.h
-- Looking for include file memory.h - not found
-- Looking for include file math.h
-- Looking for include file math.h - not found
-- Looking for fsetround
-- Looking for fsetround - not found
-- Looking for floor
-- Looking for floor - not found
-- Looking for pow
-- Looking for pow - not found
-- Looking for sqrt
-- Looking for sqrt - not found
-- Looking for strdup
-- Looking for strdup - not found
-- Looking for strstr
-- Looking for strstr - not found
-- Looking for include file strings.h
-- Looking for include file strings.h - not found
-- Looking for include file string.h
-- Looking for include file string.h - not found
-- Looking for include file sys/stat.h
-- Looking for include file sys/stat.h - not found
-- Looking for include file sys/types.h
-- Looking for include file sys/types.h - not found
-- Looking for include file unistd.h
-- Looking for include file unistd.h - not found
-- Looking for include file assert.h
-- Looking for include file assert.h - not found
-- Geant4 found: 11.2.2
-- Found Python3: /home/share/micromamba/envs/uLib/bin/python3.12 (found version "3.12.13") found components: Interpreter
-- Configuring done (9.2s)
-- Generating done (1.6s)
-- Build files have been written to: /home/rigoni/devel/cmt/uLib/build/clang-make

2
condaenv.yml
View File

@@ -9,7 +9,7 @@ dependencies:
- root
- vtk=9.4 # VTK 9.4
- pybind11
# - boost=1.86.0 # requested by VTK 9.4
#- boost=1.86.0 # requested by VTK 9.4
- ninja
- clang
- clangxx

31
docs/geant_integration.md
View File

@@ -3,32 +3,9 @@
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
Geant4 solids in `uLib` are encapsulated within the `uLib::Geant::Solid` hierarchy, with primary implementations such as `BoxSolid` and `TessellatedSolid`. These classes act as reactive wrappers around native Geant4 `G4VSolid` objects, bridging the gap between Geant4's static geometry and `uLib`'s dynamic property system.
### Property Mapping and Synchronization
The integration relies on a mapping between `uLib` properties and Geant4 parameters. This allows geometry to be driven by Qt-based property panels or interactive VTK handles. When a property is modified, the library handles the update through the following mechanism:
* **Parameter Application**: If the underlying Geant4 object supports dynamic updates (e.g., changing box dimensions via `SetXHalfLength`), `uLib` applies the change directly to the existing object.
* **Solid Re-instantiation**: In cases where Geant4 does not support on-the-fly parameter changes, the library transparently recreates the underlying `G4VSolid`. This ensures that the simulation model always reflects the current state of the design environment.
* **Global Signaling**: Once the underlying Geant4 state is synchronized, the `uLib::Geant::Solid` emits an `updated()` signal. This triggers cascading updates across all dependent observers, such as the VTK rendering pipeline and the Geant4 scene manager, ensuring visual and logical consistency.
## VTK Visualization Layer
The visualization of Geant4 solids in VTK is managed by the `uLib::Vtk::GeantSolid` class and its specializations (e.g., `vtkBoxSolid`). This class serves as a bridge between the domain model (`uLib::Geant::Solid`) and the VTK rendering pipeline, inheriting from `uLib::Vtk::Prop3D` to leverage the framework's standard transformation and property management features.
### Geometry Extraction and Rendering
Since Geant4 solids are defined by analytical or tessellated boundary representations, `GeantSolid` converts them into a format suitable for VTK:
1. **Faceted Representation**: It retrieves the `G4Polyhedron` tessellation from the underlying `G4VSolid`.
2. **PolyData Mapping**: The vertices and facets of the polyhedron are extracted and mapped to a `vtkPolyData` object.
3. **Actor Configuration**: This geometry is assigned to a `vtkActor`, which is then added to the `Prop3D`. Default visual properties—such as semi-transparent surfaces and edge visibility—are applied to aid in debugging and design.
### Transform Synchronization
The spatial state (Translation, Rotation, and Scale) is synchronized between the Geant4 geometry tree and the VTK viewer ensuring a consistent representation across both domains.
* **Geant4 to VTK (Forward)**: When a solid's placement is updated in Geant4, `GeantSolid` extracts the translation and rotation from the associated `G4VPhysicalVolume`. These are converted into a `vtkTransform` and applied to the actor, aligning the visual model with the simulation's coordinate system.
* **VTK to Geant4 (Interactive)**: Interaction in the viewer (e.g., using a transformation handler) triggers the `SyncFromVtk()` method. This pushes the new transformation matrix back to the `uLib::Geant::Solid` domain object, which then updates the Geant4 physical volume.
* **Feedback Loop Prevention**: To avoid infinite recursion during interactive updates, the synchronization logic utilizes temporary signal blocking. This ensures that a transform update originating from VTK does not trigger a redundant re-update of the VTK representation from the domain model.
# 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 ).

36
docs/object_context.md
View File

@@ -1,36 +0,0 @@
# Creating Objects and adding to context
In uLib the context is meant to hold a set of objects and their hierarchy. In addition ObjectFactory is used to create objects from a predefined registry.
Object context can be thought as a collection of uLib::Object instances. And there exists nested collection of objects if a context is added to another context. A nested context is a Group of elements that appears like a single object in the parent context and a hierarchy of objects inside the tree structure.
## SmartPointer access
SmartPointer is a class that is used to hold a reference to another object. It is a template class that can be used to hold a reference to any object as a shared_ptr.
The ObjectContext is responsible to keep track of all the objects that are added to it and to provide a way to access them, but also it holds the SmartPointer instances that point to the objects that are added to it. In this way Objects added to a Context are disposed only when all the references to it are removed.
For this reason the access to a object context for a Object via Get/Set must be done using the SmartPointer instances.
## SmartPointer access
SmartPointer is a class that is used to hold a reference to another object. It is a template class that can be used to hold a reference to any object that is derived from uLib::Object. It is a smart pointer because it will automatically delete the object when it is no longer needed. It is also a smart pointer because it will automatically update the object when it is no longer needed.
The ObjectContext is responsible to keep track of all the objects that are added to it and to provide a way to access them, but also it holds the SmartPointer instances that point to the objects that are added to it. In this way Objects added to a Context are disposed only when the context is destroyed.
For this reason the access to a object context for a Object via Get/Set is done using the SmartPointer instances.
## Geant Physical Volumes
The Geant library add a further layer of complexity. The physical volumes are created from a what is called LogicalVolume (which holds information about the shape, material and daughter volumes) and represent the actual instances of the volumes in the detector. So in this sense they represent what could be the Prop3D in the uLib Vtk library. The PhysicalVolume is created from the LogicalVolume and is the one that is actually placed in the scene, with its own relative TRS: position and rotation (rotation here is a rotation matrix comprising the scaling).
so Adding a Solid or a Logical volume on the scene is not enough. We need to create a PhysicalVolume from the LogicalVolume and add it to the scene to see its instance and apply the TRS to the PhysicalVolume and so to eventually to the representation.
## Gcompose interaction with objects that have Prop3d and object without 3D actor
In VTK and Qt the objects are organized in a tree structure. When We will add a new object to the scene it will be added to the tree structure and it will be displayed once wrapped in a vtk representation (like vtkContainerBox for instance).
For objects without 3D representation, they are added to the tree structure but they are not displayed in the scene. But when Object have a internal member that is a reference to another object, this will be represented in the tree structure as a child of the object that contains a reference to it. It is also important to note that the reference can be either the object itself or a smart pointer to the object. So the representation of the child in the tree structure is a placeholder for the object that is referenced and it can be added to many parents, creating multiple instances of the same reference in the tree structure.
When a object contains a reference to another object, the reference can be set from properties by selecting form the possible instances in the context that are compatible (can be casted) to the type of the reference.
In this way the reference appears also as a child in the tree. On the other hand the same add operation can be performed by dragging the object from the tree structure and dropping it on the property of the object that contains the reference. In this case the reference will be set to the parent selecting the compatible menber automatically.

120
docs/smart_pointer.md
View File

@@ -1,120 +0,0 @@
# SmartPointer Documentation
`uLib::SmartPointer<T>` is a shared ownership smart pointer implementation designed for the `uLib` ecosystem. While it shares many similarities with `std::shared_ptr`, it includes specific features for legacy compatibility, local reference wrapping, and integrated Boost serialization.
## Table of Contents
1. [Overview](#overview)
2. [Key Differences from std::shared_ptr](#key-differences-from-stdshared_ptr)
3. [Common Usage](#common-usage)
4. [Construction and Assignment](#construction-and-assignment)
5. [Wrapping References](#wrapping-references)
6. [Polymorphism and Casting](#polymorphism-and-casting)
7. [Serialization](#serialization)
8. [Thread Safety](#thread-safety)
---
## Overview
A `SmartPointer` manages the lifetime of an object through reference counting. When the last `SmartPointer` owning an object is destroyed or reset, the object is automatically deleted (unless a custom deleter is provided).
The implementation uses an internal `ControlBlock` to manage the reference count and an optional deleter function.
## Key Differences from std::shared_ptr
| Feature | `uLib::SmartPointer<T>` | `std::shared_ptr<T>` |
| :--- | :--- | :--- |
| **Default Constructor** | Initializes to `nullptr`. | Initializes to `nullptr`. |
| **Implicit Conversion** | Implicitly converts from `T*` and to `T*`. | Explicit construction from `T*`, no implicit conversion to `T*`. |
| **Reference Wrapping** | Direct support for wrapping `T&` with a no-op deleter. | Requires explicit custom deleter `[](T*){}`. |
| **Serialization** | Built-in Boost.Serialization support. | Requires external serialization helpers. |
> [!NOTE]
> The default constructor `SmartPointer<T>()` now initializes to `nullptr`, matching standard C++ smart pointer behavior.
## Common Usage
```cpp
#include "Core/SmartPointer.h"
// 1. Allocation via default constructor (Allocates a new MyObject)
uLib::SmartPointer<MyObject> ptr;
// 2. Explicit null pointer
uLib::SmartPointer<MyObject> null_ptr(nullptr);
// 3. From raw pointer
uLib::SmartPointer<MyObject> manual_ptr(new MyObject(args));
// 4. Accessing members
ptr->DoSomething();
(*ptr).Value = 10;
// 5. Checking validity
if (ptr) {
// ...
}
```
## Construction and Assignment
### Allocation and Ownership
- `SmartPointer()`: Initializes to `nullptr` (Standard behavior).
- `SmartPointer(nullptr)`: Initializes to null.
- `SmartPointer(T* ptr)`: Takes ownership of the raw pointer (implicit conversion allowed).
- `SmartPointer(T& ref)`: Wraps an existing reference with a no-op deleter (implicit conversion allowed).
- `SmartPointer(T* ptr, Deleter d)`: Takes ownership and uses a custom deleter.
- `SmartPointer(const SmartPointer* other)`: Creates a copy from a *pointer* to another `SmartPointer`.
### Move and Copy
- Supports standard copy and move semantics. Move operations transfer ownership without incrementing the reference count.
### Pointer Access
- `get()` / `Get()`: Returns the underlying raw pointer.
- `operator T*()`: Implicit conversion to raw pointer (legacy support).
## Wrapping References
The `SmartPointer` can wrap an existing object (e.g., on the stack) without taking ownership:
```cpp
MyObject stackObj;
uLib::SmartPointer<MyObject> spt(stackObj);
// spt will NOT delete stackObj when it goes out of scope.
```
## Polymorphism and Casting
`SmartPointer` supports assignment between compatible types (base/derived). For explicit casting, use the following utilities:
- `uLib::static_pointer_cast<T>(ptr)`
- `uLib::dynamic_pointer_cast<T>(ptr)`
- `uLib::const_pointer_cast<T>(ptr)`
- `uLib::reinterpret_pointer_cast<T>(ptr)`
Example:
```cpp
uLib::SmartPointer<Derived> derived(new Derived());
uLib::SmartPointer<Base> base = derived; // Automatic upcast
auto derived2 = uLib::dynamic_pointer_cast<Derived>(base); // Downcast
```
## Serialization
`SmartPointer` is fully integrated with `boost::serialization`. It tracks `ControlBlock` identity during serialization to ensure that multiple shared pointers to the same object are correctly reconstructed as a single shared instance.
```cpp
#include <boost/archive/text_oarchive.hpp>
void save(const uLib::SmartPointer<MyObject>& ptr, std::ostream& os) {
boost::archive::text_oarchive oa(os);
oa << ptr;
}
```
## Thread Safety
- The reference count is managed using `std::atomic<uint32_t>`, making the increment/decrement operations thread-safe.
- **Note**: While the reference counter itself is thread-safe, the object pointed to by the `SmartPointer` is not automatically protected. Standard thread-safety rules for the underlying type `T` apply.
- Multiple threads can read the same `SmartPointer` concurrently. Concurrent modification (assignment/reset) of the *same* `SmartPointer` instance by different threads requires external synchronization.

6
src/Core/DataAllocator.h
View File

@@ -46,6 +46,8 @@ 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]();
@@ -139,7 +141,7 @@ public:
void MoveToRAM() {
if (m_Device == MemoryDevice::RAM)
return;
if (!m_RamData && m_Size > 0) {
if (!m_RamData && m_Size > 0 && m_Size < (static_cast<size_t>(1) << 60)) {
if (m_OwnsObjects)
m_RamData = new T[m_Size]();
else
@@ -178,7 +180,7 @@ public:
T *newRam = nullptr;
T *newVram = nullptr;
if (size > 0) {
if (size > 0 && size < (static_cast<size_t>(1) << 60)) {
if (m_OwnsObjects)
newRam = new T[size]();
else

48
src/Core/FontConfig.h
View File

@@ -1,48 +0,0 @@
#ifndef U_CORE_FONTCONFIG_H
#define U_CORE_FONTCONFIG_H
#include <string>
#include <ostream>
#include <boost/serialization/nvp.hpp>
namespace uLib {
/**
* @struct FontConfig
* @brief Basic font configuration for text properties.
*/
struct FontConfig {
std::string family;
int size;
bool bold;
bool italic;
FontConfig() : family("Arial"), size(10), bold(false), italic(false) {}
FontConfig(const std::string& fam, int sz, bool b = false, bool i = false)
: family(fam), size(sz), bold(b), italic(i) {}
bool operator==(const FontConfig& other) const {
return family == other.family && size == other.size &&
bold == other.bold && italic == other.italic;
}
bool operator!=(const FontConfig& other) const { return !(*this == other); }
template<class Archive>
void serialize(Archive& ar, const unsigned int version) {
ar & boost::serialization::make_nvp("family", family);
ar & boost::serialization::make_nvp("size", size);
ar & boost::serialization::make_nvp("bold", bold);
ar & boost::serialization::make_nvp("italic", italic);
}
};
inline std::ostream& operator<<(std::ostream& os, const FontConfig& f) {
os << f.family << " " << f.size;
if (f.bold) os << " Bold";
if (f.italic) os << " Italic";
return os;
}
} // namespace uLib
#endif // U_CORE_FONTCONFIG_H

3
src/Core/Object.cpp
View File

@@ -208,7 +208,8 @@ void Object::PrintSelf(std::ostream &o) const {
bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
const char *name) {
ObjectPrivate::Signal s = {fptr, std::string(name), sig};
if (!d) return false;
ObjectPrivate::Signal s = {fptr, std::string(name ? name : "unnamed"), sig};
d->sigv.push_back(s);
return true;
}

22
src/Core/ObjectFactory.h
View File

@@ -67,25 +67,6 @@ public:
static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT( \
g_ObjectRegistrar_, __LINE__)(registeredName);
/**
* @brief Utility wrapper that bridges factory registration and shared ownership.
*
* ObjectWrapper provides a high-level interface to handle objects that can be
* both registered in the ObjectFactory and managed through shared ownership
* using SmartPointer.
*
* One of its key roles is static registration: when instantiated with a
* class name string, it automatically registers a factory function for type T
* in the ObjectFactory singleton. This allows the factory to subsequently
* create instances of T dynamically by name.
*
* It supports multiple initialization paths, including factory-based
* construction and direct model wrapping.
*/
template <typename T> class ObjectWrapper {
public:
ObjectWrapper(const std::string &className) {
@@ -94,7 +75,6 @@ public:
}
ObjectWrapper(T *model) : m_model(model) {}
ObjectWrapper(T &model) : m_model(model) {}
template <typename U = T,
typename = std::enable_if_t<std::is_default_constructible_v<U>>>
@@ -121,7 +101,7 @@ public:
T &operator*() const { return *m_model; }
T *GetWrapped() const { return m_model.get(); }
T *get() const { return m_model.get(); }
bool operator==(const ObjectWrapper &other) const {
return m_model == other.m_model;

39
src/Core/ObjectsContext.cpp
View File

@@ -8,41 +8,30 @@ ObjectsContext::ObjectsContext() : Object() {}
ObjectsContext::~ObjectsContext() {}
void ObjectsContext::AddObject(Object* obj) {
if (obj) {
auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
return sp.get() == obj;
});
if (it == m_objects.end()) {
m_objects.push_back(SmartPointer<Object>(obj));
// Connect child's update to context's update to trigger re-renders
Object::connect(obj, &Object::Updated, this, &Object::Updated);
ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
this->Updated(); // Signal that the context has been updated
}
if (!obj || obj == this) return;
if (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);
ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
this->Updated(); // Signal that the context has been updated
}
}
void ObjectsContext::RemoveObject(Object* obj) {
auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
return sp.get() == obj;
});
auto it = std::find(m_objects.begin(), m_objects.end(), obj);
if (it != m_objects.end()) {
Object* removedObj = it->get();
// Since we are about to erase it from the vector, if it was the last reference
// it would be deleted. We might want to emit the signal BEFORE erasing.
ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, removedObj);
Object* removedObj = *it;
m_objects.erase(it);
ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, removedObj);
this->Updated(); // Signal that the context has been updated
}
}
void ObjectsContext::Clear() {
if (!m_objects.empty()) {
// Create a copy of the pointers to emit signals since m_objects might be modified or cleared
std::vector<Object*> toRemove;
for (const auto& sp : m_objects) toRemove.push_back(sp.get());
for (auto obj : toRemove) {
for (auto obj : m_objects) {
ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
}
m_objects.clear();
@@ -50,7 +39,7 @@ void ObjectsContext::Clear() {
}
}
const std::vector<SmartPointer<Object>>& ObjectsContext::GetObjects() const {
const std::vector<Object*>& ObjectsContext::GetObjects() const {
return m_objects;
}
@@ -60,7 +49,7 @@ size_t ObjectsContext::GetCount() const {
Object* ObjectsContext::GetObject(size_t index) const {
if (index < m_objects.size()) {
return m_objects[index].get();
return m_objects[index];
}
return nullptr;
}

7
src/Core/ObjectsContext.h
View File

@@ -2,7 +2,6 @@
#define U_CORE_OBJECTS_CONTEXT_H
#include "Core/Object.h"
#include "Core/SmartPointer.h"
#include <vector>
namespace uLib {
@@ -37,9 +36,9 @@ public:
/**
* @brief Returns the collection of objects.
* @return Const reference to the vector of SmartPointer<Object>.
* @return Const reference to the vector of object pointers.
*/
const std::vector<SmartPointer<Object>>& GetObjects() const;
const std::vector<Object*>& GetObjects() const;
signals:
/** @brief Signal emitted when an object is added. */
@@ -61,7 +60,7 @@ public:
Object* GetObject(size_t index) const;
private:
std::vector<SmartPointer<Object>> m_objects;
std::vector<Object*> m_objects;
};
} // namespace uLib

127
src/Core/Property.h
View File

@@ -15,15 +15,6 @@
#include "Core/Archives.h"
#include "Core/Signal.h"
#include "Core/Object.h"
#include "Core/SmartPointer.h"
// Type traits for detecting SmartPointer<T>
namespace uLib {
template<typename T> struct is_smart_pointer : std::false_type {};
template<typename T> struct is_smart_pointer<SmartPointer<T>> : std::true_type {};
template<typename T> struct smart_pointer_element { using type = void; };
template<typename T> struct smart_pointer_element<SmartPointer<T>> { using type = T; };
} // namespace uLib
namespace uLib {
@@ -225,109 +216,6 @@ private:
} // namespace uLib
namespace uLib {
/**
* @brief Base class for reference properties (SmartPointer<T> fields).
* Provides a type-erased interface for getting/setting object references
* and checking type compatibility.
*/
class ReferencePropertyBase : public PropertyBase {
public:
virtual ~ReferencePropertyBase() {}
virtual Object* GetReferencedObject() const = 0;
virtual void SetReferencedObject(Object* obj) = 0;
virtual bool IsCompatible(Object* obj) const = 0;
virtual const char* GetReferenceTypeName() const = 0;
};
/**
* @brief Typed reference property for SmartPointer<T> fields.
* Filters context objects by dynamic_cast compatibility with T.
*/
template <typename T>
class ReferenceProperty : public ReferencePropertyBase {
public:
ReferenceProperty(Object* owner, const std::string& name, SmartPointer<T>& ref,
const std::string& units = "", const std::string& group = "")
: m_owner(owner), m_name(name), m_units(units), m_group(group), m_ref(ref), m_ReadOnly(false) {
if (m_owner) m_owner->RegisterProperty(this);
}
virtual ~ReferenceProperty() {}
// PropertyBase interface
virtual const std::string& GetName() const override { return m_name; }
virtual const char* GetTypeName() const override { return typeid(SmartPointer<T>).name(); }
virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(ReferencePropertyBase)); }
virtual const std::string& GetUnits() const override { return m_units; }
virtual void SetUnits(const std::string& units) override { m_units = units; }
virtual const std::string& GetGroup() const override { return m_group; }
virtual void SetGroup(const std::string& group) override { m_group = group; }
virtual bool IsReadOnly() const override { return m_ReadOnly; }
void SetReadOnly(bool ro) { m_ReadOnly = ro; }
virtual std::string GetValueAsString() const override {
T* ptr = m_ref.Get();
if (!ptr) return "(none)";
Object* obj = dynamic_cast<Object*>(ptr);
if (obj) {
std::string iname = obj->GetInstanceName();
if (!iname.empty()) return iname;
return obj->GetClassName();
}
return "(set)";
}
// ReferencePropertyBase interface
virtual Object* GetReferencedObject() const override {
return dynamic_cast<Object*>(m_ref.Get());
}
virtual void SetReferencedObject(Object* obj) override {
if (!obj) {
m_ref = SmartPointer<T>(nullptr);
this->Updated();
if (m_owner) m_owner->Updated();
return;
}
T* casted = dynamic_cast<T*>(obj);
if (casted) {
m_ref = SmartPointer<T>(casted);
this->Updated();
if (m_owner) m_owner->Updated();
}
}
virtual bool IsCompatible(Object* obj) const override {
return dynamic_cast<T*>(obj) != nullptr;
}
virtual const char* GetReferenceTypeName() const override {
return typeid(T).name();
}
// Serialization stubs
virtual void serialize(Archive::xml_oarchive & ar, const unsigned int v) override {}
virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override {}
virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override {}
virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override {}
virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override {}
virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override {}
virtual void serialize(Archive::log_archive & ar, const unsigned int v) override {}
virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override {}
private:
Object* m_owner;
std::string m_name;
std::string m_units;
std::string m_group;
SmartPointer<T>& m_ref;
bool m_ReadOnly;
};
} // namespace uLib
namespace uLib {
namespace Archive {
@@ -379,20 +267,7 @@ public:
}
template<class T> void save_property_impl(const char* name, T& val, const char* units, bool hasRange, const T& minVal, const T& maxVal, bool isReadOnly) {
if (!m_Object) return;
if constexpr (is_smart_pointer<T>::value) {
// SmartPointer<U> field: create a ReferenceProperty<U> for type-safe selection
using ElementT = typename smart_pointer_element<T>::type;
auto* p = new ReferenceProperty<ElementT>(m_Object, name, val, units ? units : "", GetCurrentGroup());
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);
}
} else {
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);

2
src/Core/Serializable.h
View File

@@ -42,8 +42,6 @@ TODO:
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/remove_if.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/unique_ptr.hpp>
// #include <boost/archive/xml_iarchive.hpp>
// #include <boost/archive/xml_oarchive.hpp>

270
src/Core/SmartPointer.h
View File

@@ -3,7 +3,7 @@
////////////////////////////////////////////////////////////////////////////////
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
All Padua preserved
All rights reserved
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
@@ -29,119 +29,79 @@
#include <atomic>
#include <functional>
#include <type_traits>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_member.hpp>
#include <utility>
namespace uLib {
/**
* @brief Internal control block for shared ownership across polymorphic SmartPointers.
*/
struct ControlBlock {
std::atomic<uint32_t> count;
std::function<void()> deleter;
explicit ControlBlock(uint32_t initial_count = 1) : count(initial_count) {}
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int /*version*/) {
// ControlBlock identity is tracked by Boost via the cb pointer in ReferenceCounter.
// We only save the count value.
uint32_t c = count.load();
ar & boost::serialization::make_nvp("count", c);
if constexpr (Archive::is_loading::value) count.store(c);
}
};
/**
* @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 {
template <typename T>
class SmartPointer {
public:
using element_type = T;
/**
* @brief Nested reference counter structure.
* Preserved as a nested template for Boost serialization compatibility.
* @brief Constructor from raw pointer.
* If ptr is nullptr, a new T is allocated (legacy behavior).
*/
struct ReferenceCounter {
T* ptr;
ControlBlock* cb;
ReferenceCounter() : ptr(nullptr), cb(nullptr) {}
explicit ReferenceCounter(T* p) : ptr(p), cb(new ControlBlock(1)) {
cb->deleter = [p]() { delete p; };
explicit SmartPointer(T* ptr = nullptr) : m_counter(nullptr) {
if (!ptr) {
if constexpr (std::is_default_constructible_v<T>) {
ptr = new T();
}
}
template <typename D>
ReferenceCounter(T* p, D d) : ptr(p), cb(new ControlBlock(1)) {
cb->deleter = [p, d]() { d(p); };
}
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& ar, const unsigned int /*version*/) {
ar & boost::serialization::make_nvp("ptr", ptr);
ar & boost::serialization::make_nvp("cb", cb);
}
};
SmartPointer() noexcept : m_counter(nullptr) {}
SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
/**
* @brief Constructor from raw pointer (Implicit conversion allowed for legacy compatibility).
*/
SmartPointer(T* ptr) : m_counter(nullptr) {
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);
}
SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){})) { }
/**
* @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);
}
/**
* @brief Copy constructor from a pointer to SmartPointer (Legacy support).
*/
SmartPointer(const SmartPointer* other) noexcept : m_counter(nullptr) {
if (other) acquire(other->m_counter);
}
template <typename U, typename = std::enable_if_t<std::is_convertible_v<U*, T*>>>
SmartPointer(const SmartPointer<U>& other) noexcept : m_counter(nullptr) {
if (other.m_counter) {
m_counter = new ReferenceCounter();
m_counter->ptr = static_cast<T*>(other.m_counter->ptr);
m_counter->cb = other.m_counter->cb;
if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
}
}
template <typename U>
SmartPointer(const SmartPointer<U>& other, T* ptr) noexcept : m_counter(nullptr) {
if (other.m_counter) {
m_counter = new ReferenceCounter();
m_counter->ptr = ptr;
m_counter->cb = other.m_counter->cb;
if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
}
}
/**
* @brief Move constructor.
*/
SmartPointer(SmartPointer&& other) noexcept : m_counter(other.m_counter) {
other.m_counter = nullptr;
}
~SmartPointer() { release(); }
/**
* @brief Virtual destructor.
*/
virtual ~SmartPointer() { release(); }
/**
* @brief Copy assignment.
*/
SmartPointer& operator=(const SmartPointer& other) noexcept {
if (this != &other) {
release();
@@ -150,11 +110,9 @@ public:
return *this;
}
SmartPointer& operator=(T* ptr) noexcept {
reset(ptr);
return *this;
}
/**
* @brief Move assignment.
*/
SmartPointer& operator=(SmartPointer&& other) noexcept {
if (this != &other) {
release();
@@ -164,90 +122,148 @@ public:
return *this;
}
/**
* @brief Resets the smart pointer to hold a new raw pointer.
*/
void reset(T* ptr = nullptr) {
release();
if (ptr) m_counter = new ReferenceCounter(ptr);
}
/**
* @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);
}
T& operator*() const noexcept { return *(m_counter->ptr); }
/**
* @brief Dereference operator.
*/
T& operator*() const noexcept { return *m_counter->ptr; }
/**
* @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; }
T* Get() const noexcept { return get(); }
/**
* @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->cb) ? m_counter->cb->count.load(std::memory_order_relaxed) : 0;
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; }
BOOST_SERIALIZATION_SPLIT_MEMBER()
template <class Archive>
void save(Archive& ar, const unsigned int /*version*/) const {
ar & boost::serialization::make_nvp("counter", m_counter);
}
template <class Archive>
void load(Archive& ar, const unsigned int /*version*/) {
release();
ar & boost::serialization::make_nvp("counter", m_counter);
if (m_counter && m_counter->cb) {
m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
}
}
private:
template <typename U> friend class SmartPointer;
friend class boost::serialization::access;
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 {
m_counter = c;
if (c) {
m_counter = new ReferenceCounter();
m_counter->ptr = c->ptr;
m_counter->cb = c->cb;
if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
c->count.fetch_add(1, std::memory_order_relaxed);
}
}
void release() noexcept {
if (m_counter) {
if (m_counter->cb && m_counter->cb->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
if (m_counter->cb->deleter) m_counter->cb->deleter();
delete m_counter->cb;
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;
}
delete m_counter;
m_counter = nullptr;
}
}
};
template <typename T, typename U>
SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept {
return SmartPointer<T>(r, static_cast<T*>(r.get()));
/**
* @brief Global swap for SmartPointer.
*/
template <typename T>
void swap(SmartPointer<T>& a, SmartPointer<T>& b) noexcept {
a.swap(b);
}
template <typename T, typename U>
SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U>& r) noexcept {
if (auto p = dynamic_cast<T*>(r.get())) return SmartPointer<T>(r, p);
return SmartPointer<T>(nullptr);
/**
* @brief Equality comparison.
*/
template <typename T, typename U>
bool operator==(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
return a.get() == b.get();
}
template <typename T, typename U>
SmartPointer<T> const_pointer_cast(const SmartPointer<U>& r) noexcept {
return SmartPointer<T>(r, const_cast<T*>(r.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();
}
template <typename T, typename U>
SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U>& r) noexcept {
return SmartPointer<T>(r, reinterpret_cast<T*>(r.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

54
src/Core/testing/AffinityTest.cpp
View File

@@ -10,52 +10,17 @@
using namespace uLib;
std::vector<int> GetAvailableCpus() {
std::vector<int> available;
#ifdef __linux__
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
if (sched_getaffinity(0, sizeof(cpu_set_t), &cpuset) == 0) {
for (int i = 0; i < CPU_SETSIZE; ++i) {
if (CPU_ISSET(i, &cpuset)) {
available.push_back(i);
}
}
}
#endif
return available;
}
class TestThread : public Thread {
public:
void Run() override {
Thread::Sleep(200);
}
};
void TestThreadAffinity() {
std::cout << "Testing Thread Affinity..." << std::endl;
#ifdef __linux__
auto available = GetAvailableCpus();
if (available.empty()) {
std::cout << " No CPUs available for affinity test, skipping." << std::endl;
return;
}
int target_cpu = available[0];
std::cout << " Using CPU " << target_cpu << std::endl;
TestThread t;
Thread t;
t.Start();
t.SetAffinity(target_cpu);
t.SetAffinity(0); // Bind to CPU 0
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
int s = pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
if (s != 0) {
std::cerr << "Error: pthread_getaffinity_np failed with code " << s << std::endl;
assert(false);
}
assert(CPU_ISSET(target_cpu, &cpuset));
pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
assert(CPU_ISSET(0, &cpuset));
t.Join();
std::cout << " Passed (Thread bound to CPU 0)." << std::endl;
@@ -67,15 +32,9 @@ void TestThreadAffinity() {
void TestTeamAffinity() {
std::cout << "Testing Team Affinity..." << std::endl;
#ifdef __linux__
auto available = GetAvailableCpus();
if (available.size() < 2) {
std::cout << " Not enough CPUs available for Team affinity test, skipping." << std::endl;
return;
}
std::vector<int> cpus = {available[0], available[1]};
std::cout << " Using CPUs " << cpus[0] << ", " << cpus[1] << std::endl;
#ifdef _OPENMP
Team team(2);
std::vector<int> cpus = {0, 1};
team.SetAffinity(cpus);
// We check affinity inside a parallel region
@@ -89,6 +48,7 @@ void TestTeamAffinity() {
assert(CPU_ISSET(expected_cpu, &cpuset));
}
std::cout << " Passed (Team threads bound correctly)." << std::endl;
#endif
#else
std::cout << " Affinity not supported on this OS, skipping." << std::endl;
#endif

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

@@ -16,7 +16,7 @@ int main() {
std::cout << "Testing ObjectWrapper with Non-Default Constructible type..." << std::endl;
NonDefault nd(10);
uLib::ObjectWrapper<NonDefault> w2(nd);
uLib::ObjectWrapper<NonDefault> w2(&nd);
// The following would NOT compile without SFINAE:
// uLib::ObjectWrapper<NonDefault> w3;

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

@@ -150,97 +150,11 @@ int testing_hrt_class() {
class B : public virtual Object {
uLibTypeMacro(B, Object)
ULIB_SERIALIZE_ACCESS
public:
B() : m_b(1234567), m_a(nullptr) {}
int m_b;
// reference to A (serializes through ID)
A *m_a;
};
ULIB_SERIALIZABLE_OBJECT(B)
ULIB_SERIALIZE_OBJECT(B, Object) {
ar & "Object B : " & "--> m_b = " & AR(m_b) & "--> m_a = " & AR(m_a);
}
class C : public virtual Object {
uLibTypeMacro(C, Object)
ULIB_SERIALIZE_ACCESS
public:
C() : m_c(1234566) {}
int m_c;
// reference to A (serializes through ID)
SmartPointer<A> m_a;
};
ULIB_SERIALIZABLE_OBJECT(C)
ULIB_SERIALIZE_OBJECT(C, Object) {
ar & "Object C : " & "--> m_c = " & AR(m_c) & "--> m_a = " & AR(m_a);
}
int test_referece_serialization() {
A a;
{
B b,b2 ;
b.m_a = &a;
b2.m_a = &a;
std::ofstream file("test_ref.xml");
Archive::xml_oarchive(file) << NVP(b) << NVP(b2);
}
B b,b2;
{
std::ifstream file("test_ref.xml");
Archive::xml_iarchive(file) >> NVP(b) >> NVP(b2);
}
return (b.m_a->a() == a.a() && b2.m_a->a() == a.a());
}
int test_referece_smartpointer_serialization() {
SmartPointer<A> a(new A());
a->init_properties();
{
C c, c2; c.m_a = a; c2.m_a = a;
std::ofstream file("test_ref_smartpointer.xml");
Archive::xml_oarchive(file) << NVP(c) << NVP(c2);
}
C c, c2;
{
std::ifstream file("test_ref_smartpointer.xml");
Archive::xml_iarchive(file) >> NVP(c) >> NVP(c2);
}
return (c.m_a->a() == a->a() && c2.m_a->a() == a->a());
}
int main() {
BEGIN_TESTING(Serialize Test);
TEST1(test_V3f());
TEST1(testing_xml_class());
TEST1(test_referece_serialization());
TEST1(test_referece_smartpointer_serialization());
// TEST1(testing_hrt_class());
END_TESTING;

56
src/Core/testing/SmartPointerTest.cpp
View File

@@ -27,7 +27,6 @@
#include <iostream>
#include "Core/Object.h"
#include "Core/SmartPointer.h"
#include "testing-prototype.h"
@@ -35,12 +34,12 @@ using namespace uLib;
namespace Test {
struct ObjectMockInterface : public Object {
struct ObjectMockInterface {
virtual void PrintValue()=0;
virtual int& Value()=0;
};
class ObjectMock : public ObjectMockInterface {
class ObjectMock : ObjectMockInterface {
int value;
public:
int& Value() { return value; }
@@ -73,11 +72,13 @@ int main () {
SmartPointer<Test::ObjectMock> spt(new Test::ObjectMock);
TEST1(test_smpt(spt));
}
// TEST NULL POINTER //
{
SmartPointer<Test::ObjectMock> spt;
TEST1(!spt);
TEST1(test_smpt(spt));
}
{
SmartPointer<Test::ObjectMock> spt = new SmartPointer<Test::ObjectMock>;
TEST1(test_smpt(spt));
}
// TAKE REFERENCE //
@@ -87,50 +88,7 @@ int main () {
TEST1(test_smpt(spt));
}
{
Test::ObjectMock obj;
SmartPointer<Object> spt1 = obj;
SmartPointer<Test::ObjectMock> spt2 = obj;
SmartPointer<Test::ObjectMockInterface> spt = obj;
}
{
Test::ObjectMock *obj = new Test::ObjectMock;
SmartPointer<Test::ObjectMock> spt(obj);
SmartPointer<Test::ObjectMock> spt2(spt);
SmartPointer<Test::ObjectMock> spt3(spt);
SmartPointer<Test::ObjectMock> spt4(spt2);
spt->Value() = 123;
spt2->Value() = 456;
spt3->Value() = 789;
spt4->Value() = 101112;
TEST1(spt->Value() == 101112);
TEST1(spt2->Value() == 101112);
TEST1(spt3->Value() == 101112);
TEST1(spt4->Value() == 101112);
}
{
SmartPointer<Test::ObjectMock> spt = new Test::ObjectMock;
spt->Value() = 12345;
TEST1(spt->Value() == 12345);
SmartPointer<Test::ObjectMock> spt2 = spt;
TEST1(spt2->Value() == 12345);
TEST1(spt.use_count() == 2);
}
{
// Using new with custom deleter
bool deleted = false;
{
SmartPointer<int> spt(new int(10), [&](int* p) {
deleted = true;
delete p;
});
TEST1(*spt == 10);
}
TEST1(deleted == true);
}
END_TESTING;
}

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

@@ -12,8 +12,6 @@ ULIB_REGISTER_OBJECT(Material)
ULIB_REGISTER_OBJECT(Solid)
ULIB_REGISTER_OBJECT(TessellatedSolid)
ULIB_REGISTER_OBJECT(BoxSolid)
ULIB_REGISTER_OBJECT(LogicalVolume)
ULIB_REGISTER_OBJECT(PhysicalVolume)
ULIB_REGISTER_OBJECT(Scene)
ULIB_REGISTER_OBJECT(SkyPlaneEmitterPrimary)
ULIB_REGISTER_OBJECT(CylinderEmitterPrimary)

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

@@ -12,7 +12,7 @@ Material::Material(const char *name) : m_G4Data(nullptr) {
}
Material::~Material() {
// G4Material is managed by G4MaterialStore
if(m_G4Data) delete m_G4Data;
}
void Material::SetFromNist(const char *name) {

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

@@ -76,10 +76,10 @@ public:
void SetFromNist(const char *name);
template <typename Ar>
void serialize(Ar &ar, const unsigned int /*version*/) {
ar & HRP("name", std::string(m_G4Data->GetName()));
ar & HRP("density", (double)m_G4Data->GetDensity());
ar & serialization::make_hrp_enum("state", (int)m_G4Data->GetState(), {"Undefined", "Solid", "Liquid", "Gas"});
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; }

101
src/HEP/Geant/Scene.cpp
View File

@@ -15,12 +15,10 @@
#include "Solid.h"
#include "Scene.h"
#include "Matter.h"
#include "PhysicsList.hh"
#include "ActionInitialization.hh"
#include "SimulationContext.h"
#include "HEP/Detectors/DetectorChamber.h"
#include "HEP/Geant/EmitterPrimary.hh"
namespace uLib {
namespace Geant {
@@ -50,14 +48,13 @@ class SceneImpl {
public:
SceneImpl() : m_RunManager(G4RunManagerFactory::CreateRunManager(G4RunManagerType::Serial)),
m_Emitter(nullptr),
m_World(nullptr),
m_WorldBox(new ContainerBox()),
m_InitCalled(false) {
m_RunManager->SetUserInitialization(new PhysicsList);
}
~SceneImpl() {
if (m_RunManager) delete m_RunManager;
// m_World deletion is handled in Scene destructor or here
}
void Initialize() {
@@ -70,29 +67,17 @@ public:
m_InitCalled = true;
}
Vector<Solid*> m_Solids;
Vector<SmartPointer<PhysicalVolume>> m_Volumes;
PhysicalVolume* m_World;
SmartPointer<ContainerBox> m_WorldBox;
Vector<Solid *> m_Solids;
Solid *m_World = nullptr;
ContainerBox m_WorldBox;
G4RunManager *m_RunManager;
SmartPointer<EmitterPrimary> m_Emitter;
EmitterPrimary *m_Emitter;
SimulationContext m_Context;
bool m_InitCalled;
};
G4VPhysicalVolume *SceneDetectorConstruction::Construct() {
printf("SceneDetectorConstruction::Construct() called\n");
if (!m_Owner->m_World) {
printf("ERROR: m_World is NULL in SceneDetectorConstruction::Construct()\n");
return nullptr;
}
G4VPhysicalVolume *pv = m_Owner->m_World->GetG4PhysicalVolume();
if (!pv) {
printf("ERROR: GetG4PhysicalVolume returned NULL for world!\n");
} else {
printf("SceneDetectorConstruction::Construct() returns physical volume: %s\n", pv->GetName().c_str());
}
return pv;
return m_Owner->m_World->GetPhysical();
}
Scene::Scene() {
@@ -101,51 +86,40 @@ Scene::Scene() {
}
Scene::~Scene() {
// Delete solids
for(auto s : d->m_Solids) delete s;
delete d;
}
void Scene::AddVolume(PhysicalVolume *volume, PhysicalVolume *parent) {
d->m_Volumes.push_back(SmartPointer<PhysicalVolume>(volume));
void Scene::AddSolid(Solid *solid, Solid *parent) {
d->m_Solids.push_back(solid);
if (!d->m_World) {
d->m_World = solid;
} else {
solid->SetParent(parent ? parent : d->m_World);
}
}
const Solid* Scene::GetWorld() const { return d->m_World; }
ContainerBox* Scene::GetWorldBox() const { return &d->m_WorldBox; }
const Vector<Solid*>& Scene::GetSolids() const { return d->m_Solids; }
void Scene::ConstructWorldBox(const Vector3f &size, const char *material) {
d->m_WorldBox.Scale(size);
d->m_WorldBox.SetPosition(-size/2.0f);
if (!d->m_World) {
d->m_World = new Solid("World");
d->m_World->SetNistMaterial(material);
AddSolid(d->m_World);
}
G4Box *solidWorld = new G4Box("World", 0.5 * size(0), 0.5 * size(1), 0.5 * size(2));
G4LogicalVolume *logicWorld = new G4LogicalVolume(solidWorld, d->m_World->GetMaterial(), d->m_World->GetName());
d->m_World->SetLogical(logicWorld);
// Track solids for GetSolids() API
if (volume->GetLogical() && volume->GetLogical()->GetSolid()) {
d->m_Solids.push_back(volume->GetLogical()->GetSolid());
}
if (!d->m_World) {
d->m_World = volume;
}
}
const Solid* Scene::GetWorld() const {
return d->m_World ? d->m_World->GetLogical()->GetSolid() : nullptr;
}
ContainerBox* Scene::GetWorldBox() const { return d->m_WorldBox.Get(); }
const Vector<Solid*>& Scene::GetSolids() const {
return d->m_Solids;
}
const Vector<SmartPointer<PhysicalVolume>>& Scene::GetVolumes() const {
return d->m_Volumes;
}
void Scene::ConstructWorldBox(const Vector3f &size, const char *materialName) {
d->m_WorldBox->SetSize(size);
if (!d->m_World) {
BoxSolid *worldSolid = new BoxSolid("World", d->m_WorldBox);
Material *material = new Material(materialName);
LogicalVolume *worldLogical = new LogicalVolume("World");
worldLogical->SetSolid(worldSolid);
worldLogical->SetMaterial(material);
worldLogical->Update();
d->m_World = new PhysicalVolume("World", worldLogical);
AddVolume(d->m_World);
}
G4PVPlacement *physWorld = new G4PVPlacement(nullptr, G4ThreeVector(0, 0, 0), logicWorld, d->m_World->GetName(), 0, false, 0, true);
d->m_World->SetPhysical(physWorld);
}
void Scene::SetEmitter(EmitterPrimary *emitter) { d->m_Emitter = emitter; }
@@ -172,8 +146,7 @@ void Scene::RunDetectorSimulation(int nEvents, Vector<MuonEvent> &results) {
// Find detector planes
d->m_Context.detectorPlanes.clear();
for (PhysicalVolume* v : d->m_Volumes) {
Solid *s = v->GetLogical()->GetSolid();
for (Solid* s : d->m_Solids) {
if (BoxSolid* bs = dynamic_cast<BoxSolid*>(s)) {
if (DetectorChamber* dc = dynamic_cast<DetectorChamber*>(bs->GetObject())) {
d->m_Context.detectorPlanes.push_back(dc->GetWorldProjectionPlane());

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

@@ -48,7 +48,7 @@ public:
Scene();
~Scene();
void AddVolume(PhysicalVolume *volume, PhysicalVolume *parent = nullptr);
void AddSolid(Solid *solid, Solid *parent = nullptr);
void ConstructWorldBox(const Vector3f &size, const char *material);
@@ -60,9 +60,6 @@ public:
/// Get the list of solids in the scene
const Vector<Solid*>& GetSolids() const;
/// Get the list of physical volumes in the scene
const Vector<SmartPointer<PhysicalVolume>>& GetVolumes() const;
/// Set the primary generator (emitter) for the simulation.
/// The Scene does NOT take ownership of the emitter.
void SetEmitter(EmitterPrimary *emitter);

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

@@ -35,14 +35,12 @@
#include <Geant4/G4TriangularFacet.hh>
#include <Geant4/G4Box.hh>
#include <Geant4/G4PVPlacement.hh>
#include <cstddef>
#include "Math/Dense.h"
#include "Math/Transform.h"
#include "Solid.h"
#include "uLibInterface.hh"
namespace uLib {
namespace Geant {
@@ -56,125 +54,143 @@ public:
};
Solid::Solid() {}
Solid::Solid()
: m_Name("unnamed_solid"), m_Material(NULL), m_Logical(NULL), m_Physical(NULL),
m_Position(new G4ThreeVector(0,0,0)), m_Rotation(NULL) {}
Solid::Solid(const char *name) : m_Name(name) {}
Solid::Solid(const char *name)
: m_Name(name), m_Material(NULL), m_Logical(NULL), m_Physical(NULL),
m_Position(new G4ThreeVector(0,0,0)), m_Rotation(NULL) {}
Solid::~Solid() {}
void Solid::Update() {}
////////////////////////////////////////////////////////////////////////////////
//// LOGICAL VOLUME ////////////////////////////////////////////////////////////
LogicalVolume::LogicalVolume() : m_Logical(nullptr) {}
LogicalVolume::LogicalVolume(const char *name) : m_Name(name), m_Logical(nullptr) {}
LogicalVolume::~LogicalVolume() {
// G4LogicalVolume is usually managed by G4LogicalVolumeStore
Solid::~Solid() {
if (m_Position) delete m_Position;
if (m_Rotation) delete m_Rotation;
}
void LogicalVolume::Update() {
if (m_Logical) {
if (m_Material) m_Logical->SetMaterial(m_Material->GetG4Material());
if (m_Solid) m_Logical->SetSolid(m_Solid->GetG4Solid());
} else {
if (m_Material && m_Solid && m_Solid->GetG4Solid()) {
m_Logical = new G4LogicalVolume(m_Solid->GetG4Solid(), m_Material->GetG4Material(), m_Name);
void Solid::SetNistMaterial(const char *name) {
G4NistManager *nist = G4NistManager::Instance();
G4Material *mat = nist->FindOrBuildMaterial(name);
if (mat) SetMaterial(mat);
}
void Solid::SetMaterial(G4Material *material) {
if (material) {
m_Material = material;
if (m_Logical) {
m_Logical->SetMaterial(material);
} else if (GetG4Solid()) {
m_Logical = new G4LogicalVolume(GetG4Solid(), m_Material, GetName());
}
}
}
////////////////////////////////////////////////////////////////////////////////
//// PHYSICAL VOLUME ///////////////////////////////////////////////////////////
void Solid::SetTransform(Matrix4f transform) {
uLib::AffineTransform t;
t.SetMatrix(transform);
PhysicalVolume::PhysicalVolume()
: m_Name("unnamed_pv"), m_Logical(), m_Physical(nullptr) {}
// 2. Extract position and rotation for Geant4
Vector3f pos = t.GetPosition();
if (!m_Position) m_Position = new G4ThreeVector();
*m_Position = G4ThreeVector(pos(0), pos(1), pos(2));
PhysicalVolume::PhysicalVolume(LogicalVolume *logical)
: m_Name("unnamed_pv"), m_Logical(logical), m_Physical(nullptr) {
if (m_Logical) Object::connect(m_Logical.Get(), &Object::Updated, this, &PhysicalVolume::Update);
// Create a G4 rotation matrix from the 4x4 matrix
Matrix3f m = t.GetRotation();
if (!m_Rotation) m_Rotation = new G4RotationMatrix();
m_Rotation->set(G4ThreeVector(m(0,0), m(1,0), m(2,0)),
G4ThreeVector(m(0,1), m(1,1), m(2,1)),
G4ThreeVector(m(0,2), m(1,2), m(2,2)));
// 3. If object is already placed, update its transformation
if (m_Physical) {
m_Physical->SetTranslation(*m_Position);
m_Physical->SetRotation(m_Rotation);
}
std::cout << "Solid " << GetName() << " position: " << pos << " rotation: " << m << std::endl;
}
PhysicalVolume::PhysicalVolume(const char *name, LogicalVolume *logical)
: m_Name(name), m_Logical(logical), m_Physical(nullptr) {
if (m_Logical) Object::connect(m_Logical.Get(), &Object::Updated, this, &PhysicalVolume::Update);
}
PhysicalVolume::~PhysicalVolume() {
// G4PVPlacement is usually managed by G4PhysicalVolumeStore
}
void PhysicalVolume::Update() {
if (!m_Logical) return;
m_Logical->Update();
G4LogicalVolume *g4lv = m_Logical->GetG4LogicalVolume();
if (!g4lv) return;
G4Transform3D t = ToG4Transform(this->GetMatrix());
if (m_Physical) {
m_Physical->SetTranslation(t.getTranslation());
const G4RotationMatrix *oldRot = m_Physical->GetRotation();
if (oldRot) delete oldRot;
// SetRotation takes the rotation of the object relative to mother
// For G4PVPlacement initialized with G4Transform3D, it stores the INVERSE
// of the rotation part of the transform.
m_Physical->SetRotation(new G4RotationMatrix(t.getRotation().inverse()));
m_Physical->SetLogicalVolume(g4lv);
} else {
m_Physical = new G4PVPlacement(t, g4lv, m_Name, nullptr, false, 0);
void Solid::SetParent(Solid *parent) {
if (!m_Logical) {
std::cerr << "logical volume not created for solid " << GetName() << std::endl;
return;
}
if(m_Physical) {
std::cerr << "physical volume already created for solid " << GetName() << std::endl;
return;
}
G4LogicalVolume* parentLogical = nullptr;
if (parent) {
parentLogical = parent->GetLogical();
if (!parentLogical) {
std::cerr << "parent logical volume not created for solid " << parent->GetName() << std::endl;
return;
}
}
// G4PVPlacement
m_Physical = new G4PVPlacement(
m_Rotation, // Rotation
*m_Position, // Position (translation) inside the parent
m_Logical, // The logical volume of this solid (the child)
GetName(), // Name of the physical volume
parentLogical, // The logical volume of the parent (nullptr if it's the World volume)
false, // Boolean operations (usually false)
0, // Copy number
true // Check overlaps (useful to enable in debug phase)
);
}
////////////////////////////////////////////////////////////////////////////////
//// TESSELLATED SOLID /////////////////////////////////////////////////////////
TessellatedSolid::TessellatedSolid()
: Solid("unnamed_tessellated"), m_Solid(new G4TessellatedSolid("unnamed_tessellated")) {}
: BaseClass("unnamed_tessellated"), m_Solid(new G4TessellatedSolid("unnamed_tessellated")) {}
TessellatedSolid::TessellatedSolid(const char *name)
: Solid(name), m_Solid(new G4TessellatedSolid(name)) {}
void TessellatedSolid::SetMesh(const TriangleMesh *mesh) {
this->m_Mesh = const_cast<TriangleMesh*>(mesh);
if (!mesh) return;
: BaseClass(name), m_Solid(new G4TessellatedSolid(name)) {
}
void TessellatedSolid::SetMesh(TriangleMesh &mesh) {
this->m_Mesh = mesh;
G4TessellatedSolid *ts = this->m_Solid;
for (size_t i = 0; i < mesh->Triangles().size(); ++i) {
const Vector3i &trg = mesh->Triangles().at(i);
for (int i = 0; i < mesh.Triangles().size(); ++i) {
const Vector3i &trg = mesh.Triangles().at(i);
G4TriangularFacet *facet = new G4TriangularFacet(
DetectorsSolidImpl::getG4Vector3f(mesh->Points().at(trg(0))),
DetectorsSolidImpl::getG4Vector3f(mesh->Points().at(trg(1))),
DetectorsSolidImpl::getG4Vector3f(mesh->Points().at(trg(2))), ABSOLUTE);
DetectorsSolidImpl::getG4Vector3f(mesh.Points().at(trg(0))),
DetectorsSolidImpl::getG4Vector3f(mesh.Points().at(trg(1))),
DetectorsSolidImpl::getG4Vector3f(mesh.Points().at(trg(2))), ABSOLUTE);
ts->AddFacet((G4VFacet *)facet);
}
ts->SetSolidClosed(true);
if (this->m_Logical) {
this->m_Logical->SetSolid(ts);
}
}
void TessellatedSolid::Update() {}
void TessellatedSolid::Update() {
}
////////////////////////////////////////////////////////////////////////////////
//// BOX SOLID /////////////////////////////////////////////////////////////////
BoxSolid::BoxSolid() :
Solid(),
m_ContainerBox(new ContainerBox()),
m_Solid(new G4Box("unnamed_box", 1, 1, 1))
{}
BoxSolid::BoxSolid(const char *name) :
Solid(name),
BaseClass(name),
m_ContainerBox(new ContainerBox()),
m_Solid(new G4Box(name, 1, 1, 1))
{}
BoxSolid::BoxSolid(const char *name, SmartPointer<ContainerBox> box) :
Solid(name),
m_ContainerBox(box),
m_Solid(new G4Box(name, 1, 1, 1)) {
if (box) Object::connect(box.Get(), &ContainerBox::Updated, this, &BoxSolid::Update);
BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
m_Solid = new G4Box(name, 1, 1, 1);
m_ContainerBox = box;
Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
if (m_Logical) {
m_Logical->SetSolid(m_Solid);
}
Update();
}
@@ -184,7 +200,25 @@ void BoxSolid::Update() {
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();
// 2. Center = Corner + Rotation * (Half-Size)
// We must rotate the offset vector because uLib box can be rotated.
Vector3f center = pos + rot * (size * 0.5);
uLib::AffineTransform t;
t.SetPosition(center);
t.SetRotation(rot);
this->SetTransform(t.GetMatrix());
}
}

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

@@ -28,15 +28,11 @@
#include "Core/Object.h"
#include "Geant/Matter.h"
#include "Math/Transform.h"
#include <Geant4/G4LogicalVolume.hh>
#include "Math/ContainerBox.h"
#include "Math/Dense.h"
#include "Math/TriangleMesh.h"
class G4Material;
class G4LogicalVolume;
class G4TessellatedSolid;
@@ -46,188 +42,103 @@ namespace uLib {
namespace Geant {
class Solid : public Object {
uLibTypeMacro(Solid, Object)
ULIB_SERIALIZE_ACCESS
ULIB_DECLARE_PROPERTIES(Solid)
public:
uLibTypeMacro(Solid, Object)
Solid();
Solid(const char *name);
virtual ~Solid();
void SetNistMaterial(const char *name);
void SetMaterial(G4Material *material);
void SetSizeUnit(const char *unit);
// Implementiamo SetParent qui, per tutti.
virtual void SetParent(Solid *parent);
// Setters per la posizione (necessari per il piazzamento)
void SetTransform(Matrix4f transform);
uLibGetMacro(Material, G4Material *)
uLibGetSetMacro(Logical, G4LogicalVolume *)
uLibGetSetMacro(Physical, G4VPhysicalVolume *)
virtual G4VSolid* GetG4Solid() const { return nullptr; }
inline const char *GetName() const {
return m_Name.c_str();
return m_Logical ? m_Logical->GetName().c_str() : m_Name.c_str();
}
template < typename Ar >
void serialize(Ar &ar, const unsigned int version) {
ar & HRP("Name", m_Name);
ar & m_Name;
}
public slots:
virtual void Update();
protected:
std::string m_Name;
};
class LogicalVolume : public Object {
uLibTypeMacro(LogicalVolume, Object)
ULIB_SERIALIZE_ACCESS
ULIB_DECLARE_PROPERTIES(LogicalVolume)
public:
LogicalVolume();
LogicalVolume(const char *name);
virtual ~LogicalVolume();
virtual G4VSolid* GetG4Solid() const { return m_Solid ? m_Solid->GetG4Solid() : nullptr; }
Solid* GetSolid() const { return m_Solid.Get(); }
inline const char *GetName() const {
return m_Logical ? m_Logical->GetName().c_str() : m_Name.c_str();
}
void SetSolid(SmartPointer<Solid> solid) { m_Solid = solid; }
void SetMaterial(SmartPointer<Material> material) { m_Material = material; }
G4LogicalVolume* GetG4LogicalVolume() const { return m_Logical; }
template < typename Ar >
void serialize(Ar &ar, const unsigned int version) {
ar & HRP("Name", m_Name);
ar & HRP("Material", m_Material);
ar & HRP("Solid", m_Solid);
}
public slots:
virtual void Update();
protected:
std::string m_Name;
SmartPointer<Material> m_Material;
SmartPointer<Solid> m_Solid;
G4Material *m_Material;
G4LogicalVolume *m_Logical;
G4VPhysicalVolume *m_Physical; // <-- Memorizza l'oggetto posizionato
G4ThreeVector *m_Position; // <-- Offset rispetto al centro del padre
G4RotationMatrix* m_Rotation; // <-- Rotazione rispetto al padre
};
class PhysicalVolume : public TRS {
uLibTypeMacro(PhysicalVolume, TRS)
ULIB_SERIALIZE_ACCESS
public:
PhysicalVolume();
PhysicalVolume(LogicalVolume *logical);
PhysicalVolume(const char *name, LogicalVolume *logical);
virtual ~PhysicalVolume();
LogicalVolume* GetLogical() const { return m_Logical.Get(); }
virtual G4VPhysicalVolume* GetG4PhysicalVolume() {
if (!m_Physical) Update();
return m_Physical;
}
const char* GetName() const { return m_Name.c_str(); }
template <typename Ar>
void serialize(Ar &ar, const unsigned int version) {
ar & boost::serialization::base_object<TRS>(*this);
ar & HRP("Name", m_Name);
ar & HRP("Logical", m_Logical);
}
public slots:
void Update();
protected:
std::string m_Name;
SmartPointer<LogicalVolume> m_Logical;
G4VPhysicalVolume *m_Physical;
ULIB_DECLARE_PROPERTIES(PhysicalVolume)
};
class TessellatedSolid : public Solid {
uLibTypeMacro(TessellatedSolid, Solid)
ULIB_SERIALIZE_ACCESS
public:
uLibTypeMacro(TessellatedSolid, Solid)
TessellatedSolid();
TessellatedSolid(const char *name);
void SetMesh(const TriangleMesh *mesh);
void SetMesh(TriangleMesh &mesh);
uLibGetMacro(Solid, G4TessellatedSolid *)
virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
const TriangleMesh* GetMesh() const { return m_Mesh.get(); }
const TriangleMesh& GetMesh() const { return m_Mesh; }
virtual void Update() override;
public slots:
void Update();
protected:
SmartPointer<TriangleMesh> m_Mesh;
private :
TriangleMesh m_Mesh;
G4TessellatedSolid *m_Solid;
//ULIB_DECLARE_PROPERTIES(TessellatedSolid)
};
////////////////////////////////////////////////////////////////////////////////
//// BOX SOLID /////////////////////////////////////////////////////////////////
class BoxSolid : public Solid {
uLibTypeMacro(BoxSolid, Solid)
ULIB_SERIALIZE_ACCESS
public:
BoxSolid();
BoxSolid(const char *name);
BoxSolid(const char *name, SmartPointer<ContainerBox> box);
public:
uLibTypeMacro(BoxSolid, Solid)
BoxSolid(const char *name = "");
BoxSolid(const char *name, ContainerBox *box);
virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
virtual void Update() override;
ContainerBox* GetObject() const { return m_ContainerBox; }
template < typename Ar >
void serialize(Ar &ar, const unsigned int version) {
ar & boost::serialization::base_object<Solid>(*this);
ar & HRP("Container", m_ContainerBox);
ar & boost::serialization::base_object<BaseClass>(*this);
ar & m_ContainerBox;
}
private:
SmartPointer<ContainerBox> m_ContainerBox;
public slots:
void Update();
private:
ContainerBox *m_ContainerBox;
G4Box *m_Solid;
ULIB_DECLARE_PROPERTIES(BoxSolid)
};

1
src/HEP/Geant/testing/CMakeLists.txt
View File

@@ -5,7 +5,6 @@ set(TESTS
GeantApp
ActionInitialization
SkyPlaneEmitterTest
MaterialTest
)
set(LIBRARIES

16
src/HEP/Geant/testing/EventTest.cpp
View File

@@ -25,17 +25,11 @@ int main() {
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
// 2. Create iron cube (1m x 1m x 1m) at center
ContainerBox *iron_box = new ContainerBox(Vector3f(1000, 1000, 1000)); // mm
Geant::BoxSolid *iron_cube = new Geant::BoxSolid("IronCube", iron_box);
Geant::Material *iron_mat = new Geant::Material("G4_Fe");
Geant::LogicalVolume *iron_lv = new Geant::LogicalVolume("IronCube_lv");
iron_lv->SetSolid(iron_cube);
iron_lv->SetMaterial(iron_mat);
iron_lv->Update();
Geant::PhysicalVolume *iron_pv = new Geant::PhysicalVolume("IronCube", iron_lv);
scene.AddVolume(iron_pv);
ContainerBox iron_box(Vector3f(1000, 1000, 1000)); // mm
Geant::BoxSolid *iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
iron_cube->SetNistMaterial("G4_Fe");
iron_cube->Update(); // apply dimensions
scene.AddSolid(iron_cube);
// 3. Set up emitter (default: mu- at 1 GeV, from z=+10m downward)
Geant::EmitterPrimary *emitter = new Geant::EmitterPrimary();

64
src/HEP/Geant/testing/MaterialTest.cpp
View File

@@ -1,64 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
All rights reserved
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
------------------------------------------------------------------
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library.
//////////////////////////////////////////////////////////////////////////////*/
#include <iostream>
#include "HEP/Geant/Matter.h"
#include "testing-prototype.h"
using namespace uLib::Geant;
int test_nist_materials() {
Material air("G4_AIR");
if (!air.GetG4Material()) {
std::cerr << "Failed to find G4_AIR" << std::endl;
return 0;
}
std::cout << "Air name: " << air.GetG4Material()->GetName() << std::endl;
std::cout << "Air density: " << air.GetG4Material()->GetDensity() << " g/cm3" << std::endl;
Material lead("G4_Pb");
if (!lead.GetG4Material()) {
std::cerr << "Failed to find G4_Pb" << std::endl;
return 0;
}
std::cout << "Lead name: " << lead.GetG4Material()->GetName() << std::endl;
std::cout << "Lead density: " << lead.GetG4Material()->GetDensity() << " g/cm3" << std::endl;
Material water("G4_WATER");
if (!water.GetG4Material()) {
std::cerr << "Failed to find G4_WATER" << std::endl;
return 0;
}
std::cout << "Water name: " << water.GetG4Material()->GetName() << std::endl;
std::cout << "Water density: " << water.GetG4Material()->GetDensity() << " g/cm3" << std::endl;
return 1;
}
int main() {
BEGIN_TESTING(Material);
TEST1(test_nist_materials());
END_TESTING;
}

36
src/HEP/Geant/testing/SkyPlaneEmitterTest.cpp
View File

@@ -15,7 +15,7 @@ using namespace uLib;
int main(int argc, char** argv) {
int nEvents = 100;
int nEvents = 10000;
if (argc > 1) {
nEvents = std::stoi(argv[1]);
}
@@ -24,16 +24,13 @@ int main(int argc, char** argv) {
Geant::Scene scene;
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
ContainerBox *iron_box = new ContainerBox();
iron_box->Scale(Vector3f(18_m, 10_cm, 18_m));
iron_box->SetPosition(Vector3f(-9_m, -5_cm, -9_m));
Geant::BoxSolid *iron_cube = new Geant::BoxSolid("IronCube", iron_box);
Geant::Material *iron_mat = new Geant::Material("G4_Fe");
Geant::LogicalVolume *iron_lv = new Geant::LogicalVolume("IronCube_lv");
iron_lv->SetSolid(iron_cube);
iron_lv->SetMaterial(iron_mat);
iron_lv->Update();
scene.AddVolume(new Geant::PhysicalVolume("IronCube", iron_lv));
ContainerBox iron_box;
iron_box.Scale(Vector3f(18_m, 10_cm, 18_m));
iron_box.SetPosition(Vector3f(-9_m, -5_cm, -9_m));
Geant::BoxSolid* iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
iron_cube->SetNistMaterial("G4_Fe");
iron_cube->Update();
scene.AddSolid(iron_cube);
// Top Detector Chamber (along Y axis)
DetectorChamber* top_chamber_box = new DetectorChamber();
@@ -41,12 +38,9 @@ int main(int argc, char** argv) {
top_chamber_box->Rotate(90_deg, Vector3f(1, 0, 0));
top_chamber_box->SetPosition(Vector3f(-10_m, 12_m, -10_m));
Geant::BoxSolid* top_chamber = new Geant::BoxSolid("TopChamber", top_chamber_box);
SmartPointer<Geant::Material> air_mat(new Geant::Material("G4_AIR"));
Geant::LogicalVolume* top_chamber_lv = new Geant::LogicalVolume("TopChamber_lv");
top_chamber_lv->SetSolid(top_chamber);
top_chamber_lv->SetMaterial(air_mat);
top_chamber_lv->Update();
scene.AddVolume(new Geant::PhysicalVolume("TopChamber", top_chamber_lv));
top_chamber->SetNistMaterial("G4_AIR");
top_chamber->Update();
scene.AddSolid(top_chamber);
// Bottom Detector Chamber (along Y axis)
DetectorChamber* bottom_chamber_box = new DetectorChamber();
@@ -54,11 +48,9 @@ int main(int argc, char** argv) {
bottom_chamber_box->Rotate(90_deg, Vector3f(1, 0, 0));
bottom_chamber_box->SetPosition(Vector3f(-10_m, -12_m, -10_m));
Geant::BoxSolid* bottom_chamber = new Geant::BoxSolid("BottomChamber", bottom_chamber_box);
Geant::LogicalVolume* bottom_chamber_lv = new Geant::LogicalVolume("BottomChamber_lv");
bottom_chamber_lv->SetSolid(bottom_chamber);
bottom_chamber_lv->SetMaterial(air_mat);
bottom_chamber_lv->Update();
scene.AddVolume(new Geant::PhysicalVolume("BottomChamber", bottom_chamber_lv));
bottom_chamber->SetNistMaterial("G4_AIR");
bottom_chamber->Update();
scene.AddSolid(bottom_chamber);
// Setup SkyPlaneEmitterPrimary
Geant::SkyPlaneEmitterPrimary* emitter = new Geant::SkyPlaneEmitterPrimary();

87
src/HEP/Geant/testing/SolidTest.cpp
View File

@@ -1,6 +1,8 @@
#include "Geant/Solid.h"
#include "Math/TriangleMesh.h"
#include "testing-prototype.h"
#include <Geant4/G4Material.hh>
#include <Geant4/G4NistManager.hh>
#include <Geant4/G4LogicalVolume.hh>
#include <Geant4/G4TessellatedSolid.hh>
#include <string.h>
@@ -10,51 +12,62 @@ using namespace uLib;
int main() {
BEGIN_TESTING(Geant Solid);
// Test Solid initialization //
// Test Solid initialization and NIST material //
{
Geant::Solid solid("test_solid");
TEST1(strcmp(solid.GetName(), "test_solid") == 0);
}
// Test BoxSolid //
{
Geant::BoxSolid boxsolid("test_boxsolid");
TEST1(boxsolid.GetG4Solid() != nullptr);
}
// Test LogicalVolume //
{
Geant::BoxSolid *box = new Geant::BoxSolid("box");
Geant::Material *mat = new Geant::Material("G4_AIR");
Geant::LogicalVolume lv("test_lv");
// Logical volume is not created until material and solid are set
TEST1(solid.GetLogical() == nullptr);
lv.SetSolid(box);
lv.SetMaterial(mat);
lv.Update();
TEST1(lv.GetG4LogicalVolume() != nullptr);
TEST1(strcmp(lv.GetName(), "test_lv") == 0);
solid.SetNistMaterial("G4_AIR");
// Still null because base Solid has no GetG4Solid()
TEST1(solid.GetLogical() == nullptr);
TEST1(solid.GetMaterial() != nullptr);
TEST1(solid.GetMaterial()->GetName() == "G4_AIR");
}
// Test PhysicalVolume //
{
Geant::LogicalVolume *lv = new Geant::LogicalVolume("lv");
Geant::PhysicalVolume pv("test_pv", lv);
TEST1(pv.GetLogical() == lv);
TEST1(strcmp(pv.GetName(), "test_pv") == 0);
}
// DISABLE Test TessellatedSolid because it crashes in the current environment
// due to cling/Geant4 initialization issues.
/*
// Test TessellatedSolid with a simple mesh //
{
Geant::TessellatedSolid tsolid("test_tessellated");
...
TEST1(((G4TessellatedSolid*)tsolid.GetG4Solid())->GetNumberOfFacets() == 12);
tsolid.SetNistMaterial("G4_AIR");
TEST1(tsolid.GetLogical() != nullptr);
TEST1(tsolid.GetSolid() != nullptr);
// cube mesh //
TriangleMesh mesh;
mesh.AddPoint(Vector3f(0,0,0));
mesh.AddPoint(Vector3f(1,0,0));
mesh.AddPoint(Vector3f(0,1,0));
mesh.AddPoint(Vector3f(1,1,0));
mesh.AddPoint(Vector3f(0,0,1));
mesh.AddPoint(Vector3f(1,0,1));
mesh.AddPoint(Vector3f(0,1,1));
mesh.AddPoint(Vector3f(1,1,1));
// create triangles (consistent outward winding) //
// bottom (z=0)
mesh.AddTriangle(Vector3i(0,2,3));
mesh.AddTriangle(Vector3i(0,3,1));
// top (z=1)
mesh.AddTriangle(Vector3i(4,5,7));
mesh.AddTriangle(Vector3i(4,7,6));
// left (x=0)
mesh.AddTriangle(Vector3i(0,4,6));
mesh.AddTriangle(Vector3i(0,6,2));
// right (x=1)
mesh.AddTriangle(Vector3i(1,3,7));
mesh.AddTriangle(Vector3i(1,7,5));
// front (y=0)
mesh.AddTriangle(Vector3i(0,1,5));
mesh.AddTriangle(Vector3i(0,5,4));
// back (y=1)
mesh.AddTriangle(Vector3i(2,6,7));
mesh.AddTriangle(Vector3i(2,7,3));
tsolid.SetMesh(mesh);
TEST1(tsolid.GetSolid()->GetNumberOfFacets() == 12);
}
*/
printf("All Tests Passed Successfully!\n");
END_TESTING
}

55
src/HEP/Geant/uLibInterface.hh
View File

@@ -1,55 +0,0 @@
#ifndef ULIB_GEANT_ULIB_INTERFACE_HH
#define ULIB_GEANT_ULIB_INTERFACE_HH
#include "Math/Transform.h"
#include <Geant4/G4Transform3D.hh>
#include <Geant4/G4ThreeVector.hh>
#include <Geant4/G4RotationMatrix.hh>
namespace uLib {
namespace Geant {
/**
* @brief Converts a uLib::Matrix3f to a Geant4 G4RotationMatrix.
*/
inline G4RotationMatrix ToG4Rotation(const Matrix3f& m) {
G4RotationMatrix rot;
rot.set(G4ThreeVector(m(0, 0), m(1, 0), m(2, 0)),
G4ThreeVector(m(0, 1), m(1, 1), m(2, 1)),
G4ThreeVector(m(0, 2), m(1, 2), m(2, 2)));
return rot;
}
/**
* @brief Converts a uLib::Matrix4f to a Geant4 G4Transform3D.
*/
inline G4Transform3D ToG4Transform(const Matrix4f& m) {
G4RotationMatrix rot = ToG4Rotation(m.block<3, 3>(0, 0));
G4ThreeVector pos(m(0, 3), m(1, 3), m(2, 3));
return G4Transform3D(rot, pos);
}
inline void ToG4Transform(const Matrix4f& m, G4Transform3D& g4m) {
g4m = ToG4Transform(m);
}
/**
* @brief Converts a uLib::AffineTransform to a Geant4 G4Transform3D.
*/
inline G4Transform3D ToG4Transform(const AffineTransform& at) {
return ToG4Transform(at.GetMatrix());
}
/**
* @brief Converts a uLib::Vector3f to a Geant4 G4ThreeVector.
*/
inline G4ThreeVector ToG4Vector(const Vector3f& v) {
return G4ThreeVector(v(0), v(1), v(2));
}
} // namespace Geant
} // namespace uLib
#endif // ULIB_GEANT_ULIB_INTERFACE_HH

31
src/Math/Assembly.cpp
View File

@@ -37,27 +37,18 @@ Assembly::Assembly(const Assembly &copy)
m_GroupSelection(copy.m_GroupSelection) {}
Assembly::~Assembly() {
for (auto const& [obj, conn] : m_ChildConnections) {
conn.disconnect();
}
m_ChildConnections.clear();
}
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);
// Connect to child updates to recompute AABB
m_ChildConnections[obj] = Object::connect(obj, &Object::Updated, [this](){
this->ComputeBoundingBox();
this->Updated(); // Signal that assembly itself changed (AABB-wise)
});
// Parent -> Child propagation for world matrix updates
Object::connect(this, &Object::Updated, obj, &Object::Updated);
this->ComputeBoundingBox();
}
@@ -67,12 +58,6 @@ void Assembly::RemoveObject(Object *obj) {
at->SetParent(nullptr);
}
auto itConn = m_ChildConnections.find(obj);
if (itConn != m_ChildConnections.end()) {
itConn->second.disconnect();
m_ChildConnections.erase(itConn);
}
ObjectsContext::RemoveObject(obj);
this->ComputeBoundingBox();
}
@@ -89,8 +74,8 @@ void Assembly::ComputeBoundingBox() {
m_BBoxMin = Vector3f(inf, inf, inf);
m_BBoxMax = Vector3f(-inf, -inf, -inf);
for (const auto& obj : objects) {
if (auto *box = dynamic_cast<ContainerBox *>(obj.get())) {
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();
@@ -104,7 +89,7 @@ void Assembly::ComputeBoundingBox() {
m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
}
}
} else if (auto *cyl = dynamic_cast<Cylinder *>(obj.get())) {
} else if (auto *cyl = dynamic_cast<Cylinder *>(obj)) {
// Cylinder: centered [-1, 1] radial, [-0.5, 0.5] height
Matrix4f m = cyl->GetMatrix();
for (int i = 0; i < 8; ++i) {
@@ -117,7 +102,7 @@ void Assembly::ComputeBoundingBox() {
m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
}
}
} else if (auto *subAsm = dynamic_cast<Assembly *>(obj.get())) {
} else if (auto *subAsm = dynamic_cast<Assembly *>(obj)) {
// Recursive AABB for nested assemblies
subAsm->ComputeBoundingBox();
Vector3f subMin, subMax;

3
src/Math/Assembly.h
View File

@@ -31,6 +31,7 @@
#include "Math/Transform.h"
namespace uLib {
namespace Vtk { class Assembly; }
/**
* @brief Assembly groups geometric objects (ContainerBox, Cylinder, etc.)
@@ -46,6 +47,7 @@ namespace uLib {
class Assembly : public ObjectsContext, public TRS {
public:
uLibTypeMacro(Assembly, ObjectsContext, TRS)
friend class Vtk::Assembly;
Assembly();
@@ -112,7 +114,6 @@ private:
bool m_ShowBoundingBox;
bool m_GroupSelection;
bool m_InUpdated = false;
std::map<Object*, Connection> m_ChildConnections;
ULIB_DECLARE_PROPERTIES(Assembly)
};

1
src/Math/Transform.h
View File

@@ -246,7 +246,6 @@ uLibTypeMacro(TRS, AffineTransform) ULIB_SERIALIZE_ACCESS
}
Matrix4f GetMatrix() const { return this->GetAffineMatrix().matrix(); }
};
inline std::ostream &operator<<(std::ostream &os, const TRS &trs) {

26
src/Math/testing/VoxImageTest.cpp
View File

@@ -89,31 +89,17 @@ int main() {
}
{
const int size = 100;
VoxImage<TestVoxel> img(Vector3i(size, size, size));
VoxImage<TestVoxel> img(Vector3i(4, 4, 4));
img.InitVoxels({0.f, 0});
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
for (int k = 0; k < size; k++) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
img[Vector3i(i, j, k)] = {static_cast<float>(i + j + k), 0};
}
}
}
img.ExportToVti("./vti_saved.vti", 0, true); // compressed
VoxImage<TestVoxel> imgR(Vector3i(0, 0, 0));
imgR.ImportFromVti("./vti_saved.vti", 0);
TEST1(img.GetDims() == imgR.GetDims());
TEST1(img.GetSpacing() == imgR.GetSpacing());
TEST1(img.GetOrigin() == imgR.GetOrigin());
TEST1(img.GetPosition() == imgR.GetPosition());
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
for (int k = 0; k < size; k++) {
TEST1(img[Vector3i(i, j, k)].Value == imgR[Vector3i(i, j, k)].Value);
}
}
}
img.ExportToVti("./vti_saved.vti", 0, 1);
// img.ImportFromVtkXml("./test_vox_image.vti");
}
{

26
src/Vtk/HEP/Geant/testing/vtkCylinderEmitterPrimaryTest.cpp
View File

@@ -75,23 +75,13 @@ int main(int argc, char** argv) {
Geant::Scene scene;
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
// Iron Cube
SmartPointer<ContainerBox> iron_box(new ContainerBox());
iron_box->Scale(Vector3f(10_m, 10_m, 10_m));
iron_box->SetPosition(Vector3f(0, 0, 0));
SmartPointer<Geant::BoxSolid> iron_solid(new Geant::BoxSolid("IronSolid", iron_box));
iron_solid->Update();
SmartPointer<Geant::Material> iron_mat(new Geant::Material("IronMat"));
iron_mat->SetFromNist("G4_Fe");
SmartPointer<Geant::LogicalVolume> iron_lv(new Geant::LogicalVolume("IronLV"));
iron_lv->SetSolid(iron_solid);
iron_lv->SetMaterial(iron_mat);
SmartPointer<Geant::PhysicalVolume> iron_pv(new Geant::PhysicalVolume("IronPV", iron_lv));
scene.AddVolume(iron_pv);
ContainerBox iron_box;
iron_box.Scale(Vector3f(10_m, 10_m, 10_m));
iron_box.SetPosition(Vector3f(0, 0, 0));
Geant::BoxSolid* iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
iron_cube->SetNistMaterial("G4_Fe");
iron_cube->Update();
scene.AddSolid(iron_cube);
// Use CylinderEmitterPrimary
Geant::CylinderEmitterPrimary* emitter = new Geant::CylinderEmitterPrimary();
@@ -113,7 +103,7 @@ int main(int argc, char** argv) {
vtkWorld->SetSelectable(false);
viewer.AddProp3D(*vtkWorld);
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(iron_box.Get());
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
viewer.AddProp3D(*vtkIron);

65
src/Vtk/HEP/Geant/testing/vtkEmitterPrimaryTest.cpp
View File

@@ -69,56 +69,31 @@ int main(int argc, char** argv) {
Geant::Scene scene;
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
// Iron Cube
SmartPointer<ContainerBox> iron_box(new ContainerBox());
iron_box->Scale(Vector3f(10_m, 10_m, 10_m));
iron_box->SetPosition(Vector3f(-5_m, -5_m, -5_m));
SmartPointer<Geant::BoxSolid> iron_solid(new Geant::BoxSolid("IronSolid", iron_box));
iron_solid->Update();
SmartPointer<Geant::Material> iron_mat(new Geant::Material("IronMat"));
iron_mat->SetFromNist("G4_Fe");
SmartPointer<Geant::LogicalVolume> iron_lv(new Geant::LogicalVolume("IronLV"));
iron_lv->SetSolid(iron_solid);
iron_lv->SetMaterial(iron_mat);
SmartPointer<Geant::PhysicalVolume> iron_pv(new Geant::PhysicalVolume("IronPV", iron_lv));
scene.AddVolume(iron_pv);
ContainerBox iron_box;
iron_box.Scale(Vector3f(10_m, 10_m, 10_m));
iron_box.SetPosition(Vector3f(-5_m, -5_m, -5_m));
Geant::BoxSolid* iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
iron_cube->SetNistMaterial("G4_Fe");
iron_cube->Update();
scene.AddSolid(iron_cube);
// Top Detector Chamber
SmartPointer<DetectorChamber> top_chamber_box(new DetectorChamber());
DetectorChamber* top_chamber_box = new DetectorChamber();
top_chamber_box->Scale(Vector3f(10_m, 10_m, 40_cm));
top_chamber_box->SetPosition(Vector3f(-5_m, -5_m, 7_m));
SmartPointer<Geant::BoxSolid> top_solid(new Geant::BoxSolid("TopSolid", top_chamber_box));
top_solid->Update();
SmartPointer<Geant::Material> air_mat(new Geant::Material("AirMat"));
air_mat->SetFromNist("G4_AIR");
SmartPointer<Geant::LogicalVolume> top_lv(new Geant::LogicalVolume("TopLV"));
top_lv->SetSolid(top_solid);
top_lv->SetMaterial(air_mat);
SmartPointer<Geant::PhysicalVolume> top_pv(new Geant::PhysicalVolume("TopPV", top_lv));
scene.AddVolume(top_pv);
Geant::BoxSolid* top_chamber = new Geant::BoxSolid("TopChamber", top_chamber_box);
top_chamber->SetNistMaterial("G4_AIR");
top_chamber->Update();
scene.AddSolid(top_chamber);
// Bottom Detector Chamber
SmartPointer<DetectorChamber> bottom_chamber_box(new DetectorChamber());
DetectorChamber* bottom_chamber_box = new DetectorChamber();
bottom_chamber_box->Scale(Vector3f(10_m, 10_m, 40_cm));
bottom_chamber_box->SetPosition(Vector3f(-5_m, -5_m, -7.1_m));
SmartPointer<Geant::BoxSolid> bottom_solid(new Geant::BoxSolid("BottomSolid", bottom_chamber_box));
bottom_solid->Update();
SmartPointer<Geant::LogicalVolume> bottom_lv(new Geant::LogicalVolume("BottomLV"));
bottom_lv->SetSolid(bottom_solid);
bottom_lv->SetMaterial(air_mat);
SmartPointer<Geant::PhysicalVolume> bottom_pv(new Geant::PhysicalVolume("BottomPV", bottom_lv));
scene.AddVolume(bottom_pv);
Geant::BoxSolid* bottom_chamber = new Geant::BoxSolid("BottomChamber", bottom_chamber_box);
bottom_chamber->SetNistMaterial("G4_AIR");
bottom_chamber->Update();
scene.AddSolid(bottom_chamber);
Geant::EmitterPrimary* emitter = new Geant::EmitterPrimary();
emitter->SetPosition(Vector3f(0, 0, 14_m));
@@ -137,20 +112,20 @@ int main(int argc, char** argv) {
viewer.AddProp3D(*vtkWorld);
// Visualize iron cube
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(iron_box.Get());
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
viewer.AddProp3D(*vtkIron);
// Visualize Top Chamber
Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box.Get());
Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box);
vtkTop->SetOpacity(0.5);
vtkTop->SetColor(0.2, 0.8, 0.2);
vtkTop->SetRepresentation(Vtk::Prop3D::Surface);
viewer.AddProp3D(*vtkTop);
// Visualize Bottom Chamber
Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box.Get());
Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box);
vtkBottom->SetOpacity(0.5);
vtkBottom->SetColor(0.2, 0.8, 0.2);
vtkBottom->SetRepresentation(Vtk::Prop3D::Surface);

25
src/Vtk/HEP/Geant/testing/vtkGeantEventTest.cpp
View File

@@ -100,22 +100,13 @@ int main(int argc, char** argv) {
Geant::Scene scene;
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
SmartPointer<ContainerBox> iron_box(new ContainerBox());
iron_box->Scale(Vector3f(10_m, 10_m, 10_m));
iron_box->SetPosition(Vector3f(-5_m, -5_m, -5_m));
SmartPointer<Geant::BoxSolid> iron_solid(new Geant::BoxSolid("IronSolid", iron_box));
iron_solid->Update();
SmartPointer<Geant::Material> iron_mat(new Geant::Material("IronMat"));
iron_mat->SetFromNist("G4_Fe");
SmartPointer<Geant::LogicalVolume> iron_lv(new Geant::LogicalVolume("IronLV"));
iron_lv->SetSolid(iron_solid);
iron_lv->SetMaterial(iron_mat);
SmartPointer<Geant::PhysicalVolume> iron_pv(new Geant::PhysicalVolume("IronPV", iron_lv));
scene.AddVolume(iron_pv);
ContainerBox iron_box;
iron_box.Scale(Vector3f(10_m, 10_m, 10_m));
iron_box.SetPosition(Vector3f(-5_m, -5_m, -5_m));
Geant::BoxSolid* iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
iron_cube->SetNistMaterial("G4_Fe");
iron_cube->Update();
scene.AddSolid(iron_cube);
RandomEmitter* emitter = new RandomEmitter();
scene.SetEmitter(emitter);
@@ -132,7 +123,7 @@ int main(int argc, char** argv) {
viewer.AddProp3D(*vtkWorld);
// Visualize iron cube
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(iron_box.Get());
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
viewer.AddProp3D(*vtkIron);

23
src/Vtk/HEP/Geant/testing/vtkGeantSceneTest.cpp
View File

@@ -33,22 +33,13 @@ int main(int argc, char** argv) {
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
// Add an iron cube inside the world
SmartPointer<ContainerBox> iron_box(new ContainerBox());
iron_box->Scale(Vector3f(10_m, 10_m, 10_m));
iron_box->SetPosition(Vector3f(-5_m, -5_m, -5_m));
SmartPointer<Geant::BoxSolid> iron_solid(new Geant::BoxSolid("IronSolid", iron_box));
iron_solid->Update();
SmartPointer<Geant::Material> iron_mat(new Geant::Material("IronMat"));
iron_mat->SetFromNist("G4_Fe");
SmartPointer<Geant::LogicalVolume> iron_lv(new Geant::LogicalVolume("IronLV"));
iron_lv->SetSolid(iron_solid);
iron_lv->SetMaterial(iron_mat);
SmartPointer<Geant::PhysicalVolume> iron_pv(new Geant::PhysicalVolume("IronPV", iron_lv));
scene.AddVolume(iron_pv);
ContainerBox iron_box;
iron_box.Scale(Vector3f(10_m, 10_m, 10_m));
iron_box.SetPosition(Vector3f(-5_m, -5_m, -5_m));
Geant::BoxSolid* iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
iron_cube->SetNistMaterial("G4_Fe");
iron_cube->Update();
scene.AddSolid(iron_cube);
scene.Initialize();
// 2. Build VTK scene representation

65
src/Vtk/HEP/Geant/testing/vtkSkyPlaneEmitterPrimaryTest.cpp
View File

@@ -66,58 +66,33 @@ int main(int argc, char** argv) {
Geant::Scene scene;
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
// Iron Cube
SmartPointer<ContainerBox> iron_box(new ContainerBox());
iron_box->Scale(Vector3f(18_m, 18_m, 18_m));
iron_box->SetPosition(Vector3f(-9_m, -9_m, -9_m));
SmartPointer<Geant::BoxSolid> iron_solid(new Geant::BoxSolid("IronSolid", iron_box));
iron_solid->Update();
SmartPointer<Geant::Material> iron_mat(new Geant::Material("IronMat"));
iron_mat->SetFromNist("G4_Fe");
SmartPointer<Geant::LogicalVolume> iron_lv(new Geant::LogicalVolume("IronLV"));
iron_lv->SetSolid(iron_solid);
iron_lv->SetMaterial(iron_mat);
SmartPointer<Geant::PhysicalVolume> iron_pv(new Geant::PhysicalVolume("IronPV", iron_lv));
scene.AddVolume(iron_pv);
ContainerBox iron_box;
iron_box.Scale(Vector3f(18_m, 18_m, 18_m));
iron_box.SetPosition(Vector3f(-9_m, -9_m, -9_m));
Geant::BoxSolid* iron_cube = new Geant::BoxSolid("IronCube", &iron_box);
iron_cube->SetNistMaterial("G4_Fe");
iron_cube->Update();
scene.AddSolid(iron_cube);
// Top Detector Chamber (along Y axis)
SmartPointer<DetectorChamber> top_chamber_box(new DetectorChamber());
DetectorChamber* top_chamber_box = new DetectorChamber();
top_chamber_box->Scale(Vector3f(20_m, 40_cm, 20_m));
top_chamber_box->Rotate(90_deg, Vector3f(1, 0, 0));
top_chamber_box->SetPosition(Vector3f(-10_m, 12_m, -10_m));
SmartPointer<Geant::BoxSolid> top_solid(new Geant::BoxSolid("TopSolid", top_chamber_box));
top_solid->Update();
SmartPointer<Geant::Material> air_mat(new Geant::Material("AirMat"));
air_mat->SetFromNist("G4_AIR");
SmartPointer<Geant::LogicalVolume> top_lv(new Geant::LogicalVolume("TopLV"));
top_lv->SetSolid(top_solid);
top_lv->SetMaterial(air_mat);
SmartPointer<Geant::PhysicalVolume> top_pv(new Geant::PhysicalVolume("TopPV", top_lv));
scene.AddVolume(top_pv);
Geant::BoxSolid* top_chamber = new Geant::BoxSolid("TopChamber", top_chamber_box);
top_chamber->SetNistMaterial("G4_AIR");
top_chamber->Update();
scene.AddSolid(top_chamber);
// Bottom Detector Chamber (along Y axis)
SmartPointer<DetectorChamber> bottom_chamber_box(new DetectorChamber());
DetectorChamber* bottom_chamber_box = new DetectorChamber();
bottom_chamber_box->Scale(Vector3f(20_m, 40_cm, 20_m));
bottom_chamber_box->Rotate(90_deg, Vector3f(1, 0, 0));
bottom_chamber_box->SetPosition(Vector3f(-10_m, -12_m, -10_m));
SmartPointer<Geant::BoxSolid> bottom_solid(new Geant::BoxSolid("BottomSolid", bottom_chamber_box));
bottom_solid->Update();
SmartPointer<Geant::LogicalVolume> bottom_lv(new Geant::LogicalVolume("BottomLV"));
bottom_lv->SetSolid(bottom_solid);
bottom_lv->SetMaterial(air_mat);
SmartPointer<Geant::PhysicalVolume> bottom_pv(new Geant::PhysicalVolume("BottomPV", bottom_lv));
scene.AddVolume(bottom_pv);
Geant::BoxSolid* bottom_chamber = new Geant::BoxSolid("BottomChamber", bottom_chamber_box);
bottom_chamber->SetNistMaterial("G4_AIR");
bottom_chamber->Update();
scene.AddSolid(bottom_chamber);
// Use SkyPlaneEmitterPrimary instead of EmitterPrimary
Geant::SkyPlaneEmitterPrimary* emitter = new Geant::SkyPlaneEmitterPrimary();
@@ -138,20 +113,20 @@ int main(int argc, char** argv) {
vtkWorld->SetSelectable(false);
viewer.AddProp3D(*vtkWorld);
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(iron_box.Get());
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Prop3D::Surface);
viewer.AddProp3D(*vtkIron);
// Visualize Top Chamber
Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box.Get());
Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box);
vtkTop->SetOpacity(0.5);
vtkTop->SetColor(0.2, 0.8, 0.2);
vtkTop->SetRepresentation(Vtk::Prop3D::Surface);
viewer.AddProp3D(*vtkTop);
// Visualize Bottom Chamber
Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box.Get());
Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box);
vtkBottom->SetOpacity(0.5);
vtkBottom->SetColor(0.2, 0.8, 0.2);
vtkBottom->SetRepresentation(Vtk::Prop3D::Surface);

68
src/Vtk/HEP/Geant/testing/vtkSolidsTest.cpp
View File

@@ -25,57 +25,53 @@ using namespace uLib;
int main(int argc, char** argv) {
bool interactive = (argc > 1 && std::string(argv[1]) == "-i");
// 3. Visualization setup
Vtk::Viewer viewer;
// 1. Create a BoxSolid
SmartPointer<ContainerBox> box(new ContainerBox());
box->Scale(Vector3f(1_m, 2_m, 3_m));
SmartPointer<Geant::BoxSolid> gBox(new Geant::BoxSolid("MyBox", box));
gBox->Update();
ContainerBox box;
box.Scale(Vector3f(1_m, 2_m, 3_m));
Geant::BoxSolid gBox("MyBox", &box);
gBox.Update();
SmartPointer<Geant::LogicalVolume> lvBox(new Geant::LogicalVolume("BoxLV"));
lvBox->SetSolid(gBox);
SmartPointer<Geant::PhysicalVolume> pvBox(new Geant::PhysicalVolume("BoxPV", lvBox));
Vtk::BoxSolid vtkBox(pvBox);
vtkBox.AddToViewer(viewer);
Vtk::BoxSolid vtkBox(&gBox);
// 2. Create a TessellatedSolid
SmartPointer<Geant::TessellatedSolid> gTess(new Geant::TessellatedSolid("MyTess"));
SmartPointer<TriangleMesh> mesh(new TriangleMesh());
// ... same points ...
mesh->Points().push_back(Vector3f(0, 0, 1_m)); // apex
mesh->Points().push_back(Vector3f(-1_m, -1_m, 0));
mesh->Points().push_back(Vector3f( 1_m, -1_m, 0));
mesh->Points().push_back(Vector3f( 1_m, 1_m, 0));
mesh->Points().push_back(Vector3f(-1_m, 1_m, 0));
Geant::TessellatedSolid gTess("MyTess");
TriangleMesh mesh;
// Create a simple pyramid
mesh.Points().push_back(Vector3f(0, 0, 1_m)); // apex
mesh.Points().push_back(Vector3f(-1_m, -1_m, 0));
mesh.Points().push_back(Vector3f( 1_m, -1_m, 0));
mesh.Points().push_back(Vector3f( 1_m, 1_m, 0));
mesh.Points().push_back(Vector3f(-1_m, 1_m, 0));
mesh->Triangles().push_back(Vector3i(1, 2, 0));
mesh->Triangles().push_back(Vector3i(2, 3, 0));
mesh->Triangles().push_back(Vector3i(3, 4, 0));
mesh->Triangles().push_back(Vector3i(4, 1, 0));
mesh->Triangles().push_back(Vector3i(1, 3, 2)); // base
mesh->Triangles().push_back(Vector3i(1, 4, 3)); // base
mesh.Triangles().push_back(Vector3i(1, 2, 0));
mesh.Triangles().push_back(Vector3i(2, 3, 0));
mesh.Triangles().push_back(Vector3i(3, 4, 0));
mesh.Triangles().push_back(Vector3i(4, 1, 0));
mesh.Triangles().push_back(Vector3i(1, 3, 2)); // base
mesh.Triangles().push_back(Vector3i(1, 4, 3)); // base
gTess->SetMesh(mesh.Get());
gTess->Update();
gTess.SetMesh(mesh);
gTess.Update();
SmartPointer<Geant::LogicalVolume> lvTess(new Geant::LogicalVolume("TessLV"));
lvTess->SetSolid(gTess);
SmartPointer<Geant::PhysicalVolume> pvTess(new Geant::PhysicalVolume("TessPV", lvTess));
Vtk::TessellatedSolid vtkTess(pvTess);
Vtk::TessellatedSolid vtkTess(&gTess);
// 3. Visualization setup
Vtk::Viewer viewer;
vtkBox.AddToViewer(viewer);
vtkTess.AddToViewer(viewer);
// Color them differently
vtkBox.SetColor(0.8, 0.2, 0.2); // Redish box
vtkTess.SetColor(0.2, 0.8, 0.2); // Greenish tess
// Position tessellated solid away from box using the PhysicalVolume
pvTess->SetPosition(Vector3f(5_m, 0, 0));
pvTess->Updated();
// Position tessellated solid away from box
Matrix4f trans = Matrix4f::Identity();
trans.block<3,1>(0,3) = Vector3f(5_m, 0, 0);
gTess.SetTransform(trans);
vtkTess.Update();
std::cout << "..:: Testing vtkSolidsTest ::.." << std::endl;
std::cout << "Box and Tessellated solids (placed via PhysicalVolumes) initialized." << std::endl;
std::cout << "Box and Tessellated solids initialized." << std::endl;
if (interactive) {
viewer.ZoomAuto();

50
src/Vtk/HEP/Geant/vtkBoxSolid.cpp
View File

@@ -24,28 +24,54 @@
namespace uLib {
namespace Vtk {
BoxSolid::BoxSolid(Geant::PhysicalVolume *content)
: GeantSolid(content), m_BoxSolid(nullptr) {
if (content && content->GetLogical()) {
m_BoxSolid = dynamic_cast<Geant::BoxSolid *>(content->GetLogical()->GetSolid());
}
}
BoxSolid::BoxSolid(Geant::BoxSolid *content)
: GeantSolid(content), m_BoxContent(content) {
this->InstallPipe();
// Connect the model's Updated event to updateTransform to ensure VTK sync
m_UpdateConnection = Object::connect(m_BoxContent, &uLib::Object::Updated, this, &BoxSolid::Update);
BoxSolid::BoxSolid(Geant::BoxSolid *solid)
: GeantSolid(solid), m_BoxSolid(solid) {
// Initial sync
this->Update();
}
BoxSolid::~BoxSolid() {
}
void BoxSolid::Update() {
ConnectionBlock blocker(m_UpdateConnection);
this->UpdateGeometry();
// Ensure base Prop3D properties (color, opacity, etc) and transform are applied
this->Prop3D::Update();
}
void BoxSolid::SyncFromVtk() {
this->Prop3D::SyncFromVtk();
if (auto* proxy = vtkProp3D::SafeDownCast(this->GetProxyProp())) {
if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
m_BoxContent->SetTransform(VtkToMatrix4f(mat));
}
}
}
void BoxSolid::UpdateGeometry() {
// Sync geometry from G4VSolid provided by GeantSolid (tessellation)
GeantSolid::UpdateGeometry();
}
void BoxSolid::UpdateTransform() {
// Take transform from Prop3D base (which uses GetContent() -> ContainerBox TRS)
this->Prop3D::Update();
}
void BoxSolid::serialize_display(uLib::Archive::display_properties_archive &ar,
const unsigned int version) {
// Expose Geant solid properties and underlying Box/TRS properties
this->Prop3D::serialize_display(ar, version);
if (m_BoxSolid) {
ar & NVP("Box", *m_BoxSolid);
if (m_BoxSolid->GetObject()) {
ar & NVP("Container", *m_BoxSolid->GetObject());
if (m_BoxContent) {
ar & NVP("Box", *m_BoxContent);
if (m_BoxContent->GetObject()) {
ar & NVP("Container", *m_BoxContent->GetObject());
}
}
}

17
src/Vtk/HEP/Geant/vtkBoxSolid.h
View File

@@ -45,22 +45,31 @@ class BoxSolid : public GeantSolid {
uLibTypeMacro(BoxSolid, uLib::Vtk::GeantSolid)
public:
BoxSolid(Geant::PhysicalVolume *content);
BoxSolid(Geant::BoxSolid *solid);
BoxSolid(Geant::BoxSolid *content);
virtual ~BoxSolid();
virtual void Update() override;
virtual void UpdateGeometry() override;
virtual void UpdateTransform() override;
virtual void SyncFromVtk() override;
virtual uLib::Object *GetContent() const override {
return m_BoxContent ? (::uLib::Object*)m_BoxContent->GetObject() : nullptr;
}
virtual void serialize_display(uLib::Archive::display_properties_archive &ar,
const unsigned int version = 0) override;
template <typename Ar>
void serialize(Ar &ar, const unsigned int version) {
ar & NVP("BoxSolid", *m_BoxSolid);
ar & NVP("BoxSolid", *m_BoxContent);
}
protected:
virtual void InstallPipe() override;
Geant::BoxSolid *m_BoxSolid;
Geant::BoxSolid *m_BoxContent;
uLib::Connection m_UpdateConnection;
ULIB_DECLARE_PROPERTIES(BoxSolid)
};

22
src/Vtk/HEP/Geant/vtkGeantScene.cpp
View File

@@ -45,29 +45,25 @@ GeantScene::GeantScene(Geant::Scene *scene)
m_WorldProp3D->ShowScaleMeasures(true);
}
// 2. Create prop3ds for each physical volume in the scene
const Vector<SmartPointer<Geant::PhysicalVolume>> &volumes = m_Scene->GetVolumes();
for (auto &volume : volumes) {
if (!volume || !volume->GetLogical() || !volume->GetLogical()->GetSolid())
continue;
Geant::PhysicalVolume *pv = volume.Get();
Geant::Solid *solid = pv->GetLogical()->GetSolid();
// 2. Create prop3ds for each non-world solid
const Geant::Solid *world = m_Scene->GetWorld();
const Vector<Geant::Solid *> &solids = m_Scene->GetSolids();
for (Geant::Solid *solid : solids) {
// Skip the world volume itself — it's already shown as the wireframe box
if (solid == m_Scene->GetWorld())
if (solid == world)
continue;
// Only create a prop3d if the solid has a valid G4VSolid
if (solid->GetG4Solid()) {
GeantSolid *vtkSolid = nullptr;
if (auto *box = dynamic_cast<Geant::BoxSolid *>(solid)) {
vtkSolid = new BoxSolid(pv);
vtkSolid = new BoxSolid(box);
} else if (auto *tess = dynamic_cast<Geant::TessellatedSolid *>(solid)) {
vtkSolid = new TessellatedSolid(pv);
vtkSolid = new TessellatedSolid(tess);
} else {
vtkSolid = new GeantSolid(pv);
vtkSolid = new GeantSolid(solid);
vtkSolid->Update();
}
if (vtkSolid) {

84
src/Vtk/HEP/Geant/vtkGeantSolid.cpp
View File

@@ -24,7 +24,6 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "vtkGeantSolid.h"
#include "Core/Monitor.h"
#include <vtkActor.h>
#include <vtkPolyData.h>
@@ -35,7 +34,6 @@
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
#include <vtkMatrix4x4.h>
#include "Vtk/Math/vtkDense.h"
#include <Geant4/G4VSolid.hh>
#include <Geant4/G4Polyhedron.hh>
@@ -44,28 +42,9 @@
namespace uLib {
namespace Vtk {
GeantSolid::GeantSolid(Geant::PhysicalVolume *content)
: m_SolidActor(vtkActor::New()), m_Volume(content), m_Solid(nullptr) {
GeantSolid::GeantSolid(Content *content)
: m_SolidActor(vtkActor::New()), m_Content(content) {
this->InstallPipe();
if (m_Volume) {
m_UpdateConnection = Object::connect(m_Volume, &uLib::Object::Updated, [this]() {
this->Update();
});
// Mandatory initial update
this->Update();
}
}
GeantSolid::GeantSolid(Geant::Solid *solid)
: m_SolidActor(vtkActor::New()), m_Volume(nullptr), m_Solid(solid) {
this->InstallPipe();
if (m_Solid) {
m_UpdateConnection = Object::connect(m_Solid, &uLib::Object::Updated, [this]() {
this->Update();
});
// Mandatory initial update
this->Update();
}
}
GeantSolid::~GeantSolid() {
@@ -79,32 +58,15 @@ vtkPolyData *GeantSolid::GetPolyData() const {
}
void GeantSolid::Update() {
ConnectionBlock blocker(m_UpdateConnection);
this->UpdateGeometry();
this->UpdateTransform();
this->Prop3D::Update();
}
void GeantSolid::SyncFromVtk() {
if (!m_Volume) return;
this->Prop3D::SyncFromVtk();
if (auto* proxy = vtkProp3D::SafeDownCast(this->GetProxyProp())) {
if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
m_Volume->SetMatrix(VtkToMatrix4f(mat));
}
}
}
void GeantSolid::UpdateGeometry() {
Geant::Solid *solid = m_Solid;
if (m_Volume && m_Volume->GetLogical()) {
solid = m_Volume->GetLogical()->GetSolid();
}
if (!m_Content)
return;
if (!solid) return;
G4VSolid *g4solid = solid->GetG4Solid();
G4VSolid *g4solid = m_Content->GetG4Solid();
if (!g4solid)
return;
@@ -149,19 +111,35 @@ void GeantSolid::UpdateGeometry() {
}
void GeantSolid::UpdateTransform() {
if (!m_SolidActor)
if (!m_Content || !m_SolidActor)
return;
if (m_Volume) {
// Apply the TRS transform directly from the PhysicalVolume
vtkNew<vtkMatrix4x4> vtkMat;
Matrix4fToVtk(m_Volume->GetMatrix(), vtkMat);
m_SolidActor->SetUserMatrix(vtkMat);
} else {
// Identity for unplaced solids
m_SolidActor->SetUserMatrix(nullptr);
// Apply the Geant4 transform (position/rotation) if placed
if (m_Content->GetPhysical()) {
auto *phys = m_Content->GetPhysical();
G4ThreeVector pos = phys->GetTranslation();
const G4RotationMatrix *rot = phys->GetRotation();
vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
transform->Identity();
transform->Translate(pos.x(), pos.y(), pos.z());
if (rot) {
// G4RotationMatrix stores the inverse of the rotation for placement
G4RotationMatrix invRot = rot->inverse();
double elements[16] = {
invRot.xx(), invRot.xy(), invRot.xz(), 0,
invRot.yx(), invRot.yy(), invRot.yz(), 0,
invRot.zx(), invRot.zy(), invRot.zz(), 0,
0, 0, 0, 1
};
vtkSmartPointer<vtkMatrix4x4> mat = vtkSmartPointer<vtkMatrix4x4>::New();
mat->DeepCopy(elements);
transform->Concatenate(mat);
}
m_SolidActor->SetUserTransform(transform);
}
m_SolidActor->Modified();
}
void GeantSolid::InstallPipe() {

18
src/Vtk/HEP/Geant/vtkGeantSolid.h
View File

@@ -43,30 +43,24 @@ namespace Vtk {
* a valid G4VSolid via GetG4Solid().
*/
class GeantSolid : public Prop3D, public Polydata {
typedef Geant::Solid Content;
public:
GeantSolid(Geant::PhysicalVolume *content);
GeantSolid(Geant::Solid *solid);
GeantSolid(Content *content);
~GeantSolid();
virtual class vtkPolyData *GetPolyData() const override;
virtual void Update() override;
virtual void SyncFromVtk() override;
virtual void UpdateGeometry();
virtual void UpdateTransform();
virtual uLib::Object *GetContent() const override {
return m_Volume ? (uLib::Object*)m_Volume : (uLib::Object*)m_Solid;
}
protected:
virtual void InstallPipe();
Geant::PhysicalVolume *m_Volume;
Geant::Solid *m_Solid;
vtkActor *m_SolidActor;
uLib::Connection m_UpdateConnection;
vtkActor *m_SolidActor;
Content *m_Content;
};
} // namespace Vtk

12
src/Vtk/HEP/Geant/vtkTessellatedSolid.cpp
View File

@@ -18,11 +18,9 @@
namespace uLib {
namespace Vtk {
TessellatedSolid::TessellatedSolid(Geant::PhysicalVolume *content)
: GeantSolid(content), m_TessSolid(nullptr) {
if (content && content->GetLogical()) {
m_TessSolid = dynamic_cast<Geant::TessellatedSolid *>(content->GetLogical()->GetSolid());
}
TessellatedSolid::TessellatedSolid(Geant::TessellatedSolid *content)
: GeantSolid(content), m_TessContent(content) {
this->Update();
}
TessellatedSolid::~TessellatedSolid() {}
@@ -33,13 +31,13 @@ void TessellatedSolid::Update() {
}
void TessellatedSolid::UpdateGeometry() {
if (!m_TessSolid || !m_TessSolid->GetMesh() || m_TessSolid->GetMesh()->Points().empty()) {
if (!m_TessContent || m_TessContent->GetMesh().Points().empty()) {
// Fallback to base tessellation if no model mesh
GeantSolid::UpdateGeometry();
return;
}
const TriangleMesh &mesh = *m_TessSolid->GetMesh();
const TriangleMesh &mesh = m_TessContent->GetMesh();
vtkNew<vtkPoints> points;
for (const auto& pt : mesh.Points()) {

4
src/Vtk/HEP/Geant/vtkTessellatedSolid.h
View File

@@ -22,14 +22,14 @@ namespace Vtk {
*/
class TessellatedSolid : public GeantSolid {
public:
TessellatedSolid(Geant::PhysicalVolume *content);
TessellatedSolid(Geant::TessellatedSolid *content);
virtual ~TessellatedSolid();
virtual void Update() override;
virtual void UpdateGeometry() override;
protected:
Geant::TessellatedSolid *m_TessSolid;
Geant::TessellatedSolid *m_TessContent;
};
} // namespace Vtk

135
src/Vtk/Math/testing/vtkAssemblyTest.cpp
View File

@@ -9,101 +9,96 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Vtk/Math/vtkAssembly.h"
#include "Math/Units.h"
#include "Vtk/Math/vtkAssembly.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "Vtk/Math/vtkCylinder.h"
#include "Vtk/uLibVtkViewer.h"
#include "Vtk/Math/vtkAssembly.h"
#include "Vtk/vtkObjectsContext.h"
#include "Vtk/uLibVtkViewer.h"
#include "Math/Units.h"
#include <vtkActor.h>
#include <vtkPropCollection.h>
#include <vtkProperty.h>
#include <vtkPropCollection.h>
#include <iostream>
using namespace uLib;
int main(int argc, char **argv) {
bool interactive = (argc > 1 && std::string(argv[1]) == "-i");
bool interactive = (argc > 1 && std::string(argv[1]) == "-i");
// ---- 1. Build model objects ----
ContainerBox box1;
box1.Scale(Vector3f(1_m, 2_m, 0.5_m));
box1.SetPosition(Vector3f(0, 0, 0));
// ---- 1. Build model objects on the heap (expected by uLib SmartPointer) ----
auto* box1 = new ContainerBox();
box1->Scale(Vector3f(1, 2, 0.5));
// box1->SetPosition(Vector3f(0, 0, 0));
ContainerBox box2;
box2.Scale(Vector3f(0.5_m, 0.5_m, 3_m));
box2.SetPosition(Vector3f(2_m, 0, 0));
auto* box2 = new ContainerBox();
box2->Scale(Vector3f(0.5, 0.5, 3));
box2->SetPosition(Vector3f(2, 0, 0));
Cylinder cyl(0.3_m, 1.5_m, 1);
cyl.SetPosition(Vector3f(0, 3_m, 0));
auto* cyl = new Cylinder(1, 1.5, 1);
cyl->SetPosition(Vector3f(0, 3, 0));
// ---- 2. Create an Assembly and add objects ----
Assembly assembly;
assembly.AddObject(&box1);
assembly.AddObject(&box2);
assembly.AddObject(&cyl);
assembly.SetShowBoundingBox(true);
// ---- 2. Create an Assembly and add objects ----
auto* assembly = new Assembly();
assembly->AddObject(box1);
assembly->AddObject(box2);
assembly->AddObject(cyl);
assembly->SetShowBoundingBox(true);
// ---- 3. Apply a group transform ----
assembly.SetPosition(Vector3f(1_m, 1_m, 0));
// ---- 3. Apply a group transform ----
// assembly->SetPosition(Vector3f(1_m, 1_m, 0));
// ---- 5. Visualize (create prop3ds to set properties) ----
Vtk::Assembly vtkAsm(&assembly);
// ---- 5. Visualize (create prop3ds to set properties) ----
Vtk::Assembly vtkAsm(assembly); // Vtk::Assembly takes ownership of the model wrapper
Vtk::Viewer viewer;
vtkAsm.AddToViewer(
viewer); // This triggers prop3d creation via ConnectRenderer which
// eventually calls Prop3D::GetProp
Vtk::Viewer viewer;
vtkAsm.AddToViewer(viewer);
// Explicitly update to ensure prop3ds exist and are added to assemblies
vtkAsm.Update();
// Explicitly update to ensure prop3ds exist and are added to assemblies
vtkAsm.Update();
// Use the child context to find child prop3ds and set colors
if (auto* childCtx = vtkAsm.GetChildrenContext()) {
auto setProps = [](Vtk::Prop3D* p, float r, float g, float b) {
if (!p) return;
vtkPropCollection* props = p->GetProps();
props->InitTraversal();
for (int i=0; i < props->GetNumberOfItems(); ++i) {
if (auto* actor = vtkActor::SafeDownCast(props->GetNextProp())) {
actor->GetProperty()->SetColor(r, g, b);
actor->GetProperty()->SetRepresentationToSurface();
actor->GetProperty()->SetOpacity(0.5);
}
}
};
// Use the child context to find child prop3ds and set colors
if (auto *childCtx = vtkAsm.GetChildrenContext()) {
auto setProps = [](Vtk::Prop3D *p, float r, float g, float b) {
if (!p)
return;
vtkPropCollection *props = p->GetProps();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
if (auto *actor = vtkActor::SafeDownCast(props->GetNextProp())) {
actor->GetProperty()->SetColor(r, g, b);
actor->GetProperty()->SetRepresentationToSurface();
actor->GetProperty()->SetOpacity(0.5);
}
}
};
setProps(childCtx->GetProp3D(box1), 1.0, 0.0, 0.0); // Red
setProps(childCtx->GetProp3D(box2), 0.0, 1.0, 0.0); // Green
setProps(childCtx->GetProp3D(cyl), 0.0, 0.0, 1.0); // Blue
}
setProps(childCtx->GetProp3D(&box1), 1.0, 0.0, 0.0); // Red
setProps(childCtx->GetProp3D(&box2), 0.0, 1.0, 0.0); // Green
setProps(childCtx->GetProp3D(&cyl), 0.0, 0.0, 1.0); // Blue
}
std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size() << " (Expected 4: 1 assembly + 3 children)" << std::endl;
std::cout << "Prop3Ds in viewport: " << viewer.getProp3Ds().size()
<< " (Expected 4: 1 assembly + 3 children)" << std::endl;
// ---- 4. Query the bounding box for terminal output ----
Vector3f bbMin, bbMax;
assembly->GetBoundingBox(bbMin, bbMax);
std::cout << "Assembly bounding box:" << std::endl;
std::cout << " min = " << bbMin.transpose() << std::endl;
std::cout << " max = " << bbMax.transpose() << std::endl;
// ---- 4. Query the bounding box for terminal output ----
Vector3f bbMin, bbMax;
assembly.GetBoundingBox(bbMin, bbMax);
std::cout << "Assembly bounding box:" << std::endl;
std::cout << " min = " << bbMin.transpose() << std::endl;
std::cout << " max = " << bbMax.transpose() << std::endl;
std::cout << "==================================================\n";
std::cout << " vtkAssemblyTest\n";
std::cout << " 2 boxes + 1 cylinder grouped in an assembly\n";
std::cout << "==================================================" << std::endl;
std::cout << "==================================================\n";
std::cout << " vtkAssemblyTest\n";
std::cout << " 2 boxes + 1 cylinder grouped in an assembly\n";
std::cout << "=================================================="
<< std::endl;
if (interactive) {
viewer.ZoomAuto();
viewer.Start();
} else {
std::cout << "Non-interactive test passed." << std::endl;
}
if (interactive) {
viewer.ZoomAuto();
viewer.Start();
} else {
std::cout << "Non-interactive test passed." << std::endl;
}
return 0;
return 0;
}

21
src/Vtk/Math/testing/vtkContainerBoxTest.cpp
View File

@@ -35,20 +35,23 @@ using namespace uLib;
int main() {
BEGIN_TESTING(vtk ContainerBox Test);
ContainerBox* box = new ContainerBox();
box->SetSize(Vector3f(1_m, 2_m, 1_m));
box->SetPosition(Vector3f(0, 0, 0));
{
ContainerBox* box = new ContainerBox();
box->Scale(Vector3f(1_m, 2_m, 1_m));
box->SetPosition(Vector3f(0, 0, 0));
Vtk::ContainerBox v_box(box);
v_box.Update();
Vtk::ContainerBox v_box(box);
v_box.Update();
v_box.SetRepresentation(Vtk::Prop3D::Surface);
v_box.SetOpacity(0.5);
v_box.SetSelectable(true);
v_box.SetRepresentation(Vtk::Prop3D::Surface);
v_box.SetOpacity(0.5);
v_box.SetSelectable(true);
}
Vtk::ContainerBox v_box;
v_box.findOrAddSignal(&Object::Updated)->connect([&v_box]() {
std::cout << "box updated: "
<< v_box.GetWrapped()->GetWorldPoint(HPoint3f(1, 1, 1)) << std::endl;
<< v_box.get()->GetWorldPoint(HPoint3f(1, 1, 1)) << std::endl;
});
if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {

2
src/Vtk/Math/testing/vtkContainerBoxTest2.cpp
View File

@@ -15,7 +15,7 @@ using namespace uLib;
int main() {
std::cout << "Creating ContainerBox..." << std::endl;
ContainerBox* box = new ContainerBox(Vector3f(1.0_m , 0.5_m, 1.0_m)); // 1x1x1 unit box
ContainerBox* box = new ContainerBox(Vector3f(1.0, 1.0, 1.0)); // 1x1x1 unit box
box->SetInstanceName("MyTestBox");
std::cout << "Creating VTK representation..." << std::endl;

20
src/Vtk/Math/testing/vtkVoxImageInteractiveTest.cpp
View File

@@ -59,9 +59,9 @@ int main(int argc, char **argv) {
// --- Image 1: Spherical Shell ---
Vector3i dims1(64, 64, 64);
VoxImage<Voxel>* img1 = new VoxImage<Voxel>(dims1);
img1->SetSpacing(Vector3f(1.0, 1.0, 1.0));
img1->SetPosition(Vector3f(-40, -32, -32));
VoxImage<Voxel> img1(dims1);
img1.SetSpacing(Vector3f(1.0, 1.0, 1.0));
img1.SetPosition(Vector3f(-40, -32, -32));
for (int z = 0; z < dims1(2); ++z) {
for (int y = 0; y < dims1(1); ++y) {
@@ -76,16 +76,16 @@ int main(int argc, char **argv) {
} else {
v.Value = 0.0f;
}
img1->operator[](Vector3i(x, y, z)) = v;
img1[Vector3i(x, y, z)] = v;
}
}
}
// --- Image 2: Axes Gradient ---
Vector3i dims2(64, 64, 64);
VoxImage<Voxel>* img2 = new VoxImage<Voxel>(dims2);
img2->SetSpacing(Vector3f(1.0, 1.0, 1.0));
img2->SetPosition(Vector3f(40, -32, -32));
VoxImage<Voxel> img2(dims2);
img2.SetSpacing(Vector3f(1.0, 1.0, 1.0));
img2.SetPosition(Vector3f(40, -32, -32));
for (int z = 0; z < dims2(2); ++z) {
for (int y = 0; y < dims2(1); ++y) {
@@ -96,15 +96,15 @@ int main(int argc, char **argv) {
(float(x) / dims2(0) + float(y) / dims2(1) + float(z) / dims2(2)) /
3.0f;
v.Value = (40.0f * val) / factor;
img2->operator[](Vector3i(x, y, z)) = v;
img2[Vector3i(x, y, z)] = v;
}
}
}
Vtk::VoxImage vtk_img1(img1);
Vtk::VoxImage vtk_img1(&img1);
vtk_img1.setShadingPreset(0);
Vtk::VoxImage vtk_img2(img2);
Vtk::VoxImage vtk_img2(&img2);
vtk_img2.setShadingPreset(1); // Use Composite without MIP for variety
Vtk::Viewer viewer;

10
src/Vtk/Math/testing/vtkVoxImageTest.cpp
View File

@@ -40,12 +40,12 @@ BOOST_AUTO_TEST_CASE(vtkVoxImageConstruction) {
TestVoxel zero = {0, 0};
TestVoxel nonzero = {5.5f * 1e-6f, 100};
VoxImage<TestVoxel>* img = new VoxImage<TestVoxel>(Vector3i(10, 10, 10));
img->SetSpacing(Vector3f(3, 3, 3));
img->InitVoxels(zero);
(*img)[Vector3i(3, 3, 3)] = nonzero;
VoxImage<TestVoxel> img(Vector3i(10, 10, 10));
img.SetSpacing(Vector3f(3, 3, 3));
img.InitVoxels(zero);
img[Vector3i(3, 3, 3)] = nonzero;
Vtk::VoxImage vtk_img(img);
Vtk::VoxImage vtk_img(&img);
vtk_img.SaveToXMLFile("test_vtkvoximage.vti");
if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {

56
src/Vtk/Math/vtkAssembly.cpp
View File

@@ -44,20 +44,14 @@ Assembly::Assembly(uLib::Assembly *content)
}
Assembly::~Assembly() {
if (this->m_model) {
Object::disconnect(this->m_model.get(), &uLib::Assembly::Updated,
this, &Assembly::Update);
}
delete m_ChildContext;
if (m_BBoxActor) m_BBoxActor->Delete();
if (m_VtkAsm) m_VtkAsm->Delete();
}
// ------------------------------------------------------------------ //
void Assembly::InstallPipe() {
// 1. Create the VTK library assembly that groups everything
m_VtkAsm = ::vtkAssembly::New();
m_VtkAsm->PickableOff();
// 1. Setup the internal VTK assembly
m_VtkAsm = vtkSmartPointer<::vtkAssembly>::New();
m_BBoxActor = vtkSmartPointer<::vtkActor>::New();
this->SetProp(m_VtkAsm);
// 2. Create the bounding-box wireframe actor
@@ -68,7 +62,6 @@ void Assembly::InstallPipe() {
vtkNew<vtkPolyDataMapper> mapper;
mapper->SetInputConnection(cube->GetOutputPort());
m_BBoxActor = vtkActor::New();
m_BBoxActor->SetMapper(mapper);
m_BBoxActor->GetProperty()->SetRepresentationToWireframe();
m_BBoxActor->GetProperty()->SetColor(1.0, 0.85, 0.0); // gold wireframe
@@ -97,14 +90,7 @@ void Assembly::Update() {
if (m_InUpdate) return;
m_InUpdate = true;
if (this->m_model && m_VtkAsm) {
// Apply world matrix from the assembly content
vtkNew<vtkMatrix4x4> m;
Matrix4fToVtk(this->m_model->GetMatrix(), m);
m_VtkAsm->SetUserMatrix(m);
m_VtkAsm->Modified();
}
// Delegate to Prop3D to handle standard transformation application (uses GetContent())
this->Prop3D::Update();
this->UpdateBoundingBox();
if (m_ChildContext)
@@ -114,25 +100,29 @@ void Assembly::Update() {
void Assembly::SyncFromVtk() {
if (m_InUpdate) return;
if (!this->m_model || !m_VtkAsm) return;
m_InUpdate = true;
// VTK -> Model: Update world matrix (accounting for model parents)
if (vtkProp3D* proxy = this->GetProxyProp()) {
this->m_model->SetWorldMatrix(VtkToMatrix4f(proxy->GetUserMatrix()));
this->m_model->FromMatrix(this->m_model->GetMatrix());
}
this->UpdateBoundingBox();
// Sync the group-level transformation from VTK to the domain model
this->Prop3D::SyncFromVtk();
// Propagate sync to children
if (m_ChildContext)
m_ChildContext->SyncFromVtk();
this->m_model->Updated(); // Notify change in model
m_InUpdate = false;
}
void Assembly::serialize_display(uLib::Archive::display_properties_archive &ar, const unsigned int version) {
// 1. Register base class appearance/transform
this->Prop3D::serialize_display(ar, version);
// 2. Map domain model properties (Bounding Box visibility, etc.)
if (this->m_model) {
ar & HRP("ShowBoundingBox", m_model->m_ShowBoundingBox);
}
}
// ------------------------------------------------------------------ //
void Assembly::UpdateBoundingBox() {
if (!this->m_model || !m_BBoxActor) return;
@@ -192,10 +182,6 @@ void Assembly::UpdateBoundingBox() {
m_BBoxActor->Modified();
}
// ------------------------------------------------------------------ //
ObjectsContext *Assembly::GetChildrenContext() const {
return m_ChildContext;
}
} // namespace Vtk
} // namespace uLib

30
src/Vtk/Math/vtkAssembly.h
View File

@@ -16,8 +16,9 @@
#include "Math/Assembly.h"
#include "Vtk/uLibVtkInterface.h"
class vtkActor;
class vtkAssembly; // VTK library forward declaration (must be before namespace)
#include <vtkSmartPointer.h>
#include <vtkActor.h>
#include <vtkAssembly.h>
namespace uLib {
namespace Vtk {
@@ -39,33 +40,36 @@ class Assembly : public Prop3D, public uLib::ObjectWrapper<uLib::Assembly> {
public:
uLibTypeMacro(Assembly, Prop3D)
Assembly(uLib::Assembly *content);
/**
* @brief Constructor.
* @param content Pointer to the domain assembly model.
*/
explicit Assembly(uLib::Assembly *content);
virtual ~Assembly();
/** @brief Updates the VTK representation from the model (model→VTK). */
virtual void Update() override;
/** @brief Synchronizes the model from the VTK representation (VTK→model). */
virtual void SyncFromVtk() override;
virtual uLib::Object* GetContent() const override { return (uLib::Object*)m_model.get(); }
virtual uLib::ObjectsContext* GetChildren() override { return (uLib::ObjectsContext*)m_model.get(); }
/**
* @brief Returns the prop3d managing child objects.
*/
/** @brief Returns the visualization context for children. */
uLib::Vtk::ObjectsContext* GetChildrenContext() const { return m_ChildContext; }
/** @brief Returns the prop3d managing child objects. */
ObjectsContext *GetChildrenContext() const;
/** @brief Property serialization for Display Properties Panel. */
void serialize_display(Archive::display_properties_archive &ar, const unsigned int version = 0) override;
private:
void UpdateBoundingBox();
void InstallPipe();
ObjectsContext *m_ChildContext;
vtkActor *m_BBoxActor;
::vtkAssembly *m_VtkAsm; // VTK library assembly — NOT this class
bool m_InUpdate; // re-entrancy guard
vtkSmartPointer<::vtkAssembly> m_VtkAsm;
vtkSmartPointer<::vtkActor> m_BBoxActor;
uLib::Vtk::ObjectsContext *m_ChildContext;
bool m_InUpdate;
};
} // namespace Vtk

96
src/Vtk/Math/vtkContainerBox.cpp
View File

@@ -38,8 +38,6 @@
#include <vtkMatrix4x4.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRendererCollection.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
@@ -52,33 +50,26 @@ struct ContainerBoxData {
vtkSmartPointer<vtkActor> m_Cube;
vtkSmartPointer<vtkActor> m_Axes;
vtkSmartPointer<vtkAssembly> m_VtkAsm;
vtkSmartPointer<vtkCubeSource> m_CubeSource;
vtkSmartPointer<vtkAxes> m_AxesSource;
uLib::Connection m_UpdateSignal;
ContainerBoxData()
: m_Cube(vtkSmartPointer<vtkActor>::New()),
m_Axes(vtkSmartPointer<vtkActor>::New()),
m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()),
m_CubeSource(vtkSmartPointer<vtkCubeSource>::New()),
m_AxesSource(vtkSmartPointer<vtkAxes>::New()) {}
m_VtkAsm(vtkSmartPointer<vtkAssembly>::New()) {}
~ContainerBoxData() {
m_UpdateSignal.disconnect();
}
};
ContainerBox::ContainerBox(uLib::ContainerBox *model)
: Prop3D(), d(new ContainerBoxData()) {
this->m_model.reset(model);
ContainerBox::ContainerBox(ContainerBox::Content *content)
: d(new ContainerBoxData()),
ObjectWrapper(content ? content : new Content()) {
this->InstallPipe();
d->m_UpdateSignal = Object::connect(
this->m_model.get(), &uLib::Object::Updated, this, &ContainerBox::Update);
this->Update();
}
ContainerBox::~ContainerBox() {
uLib::Object::disconnect(this->m_model.get(), &uLib::Object::Updated, this,
&ContainerBox::Update);
delete d;
}
ContainerBox::~ContainerBox() { delete d; }
vtkPolyData *ContainerBox::GetPolyData() const {
// TODO
@@ -90,72 +81,65 @@ void ContainerBox::Update() {
if (!this->m_model)
return;
// Update the sources with the model's dimensions.
// This makes the "natural" bounds of the actors correct for VTK gizmos.
Vector3f size = this->m_model->GetSize();
Vector3f origin = this->m_model->GetOrigin();
vtkProp3D *prop = vtkProp3D::SafeDownCast(this->GetProp());
if (prop) {
// Apply the full volume matrix (TRS * m_LocalT)
vtkNew<vtkMatrix4x4> m;
Matrix4fToVtk(this->m_model->GetMatrix(), m);
prop->SetUserMatrix(m);
prop->Modified();
}
// HandlerWidget relies on vtkProp3D::GetBounds() to determine the size
// and position of its transformation gizmos. Previously, we were applying
// the Size of the container using the actor's UserMatrix. While this looks
// correct visually, some VTK utilities (including certain internal paths
// of GetBounds()) may prioritize the bounding box of the input geometry
// (the PolyData) over the UserMatrix. This resulted in the gizmo defaulting
// to a 1x1x1 size because the underlying vtkCubeSource was still 1x1x1.
d->m_CubeSource->SetBounds(origin.x(), origin.x() + size.x(), origin.y(),
origin.y() + size.y(), origin.z(),
origin.z() + size.z());
d->m_CubeSource->Update();
d->m_AxesSource->SetOrigin(origin.x(), origin.y(), origin.z());
d->m_AxesSource->SetScaleFactor(std::max({size.x(), size.y(), size.z()}));
d->m_AxesSource->Update();
// Ensure actors have identity UserMatrix since scaling is in the source.
d->m_Cube->SetUserMatrix(nullptr);
d->m_Axes->SetUserMatrix(nullptr);
// Delegate the rest of the update (appearance, TR, render, etc) to Prop3D.
// Prop3D::Update() applies the "outer" TRS matrix (Position/Rotation/Scaling)
// to the assembly.
// Delegate rest of update (appearance, render, etc)
ConnectionBlock blocker(d->m_UpdateSignal);
this->Prop3D::Update();
}
void ContainerBox::SyncFromVtk() {
RecursiveMutex::ScopedLock lock(this->m_UpdateMutex);
if (!this->m_model)
return;
// Sync the "outer" TRS from the assembly's matrix
this->Prop3D::SyncFromVtk();
}
void ContainerBox::InstallPipe() {
if (!this->m_model)
return;
Content *c = this->m_model;
// CUBE
vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
// CUBE //
mapper->SetInputConnection(d->m_CubeSource->GetOutputPort());
cube->SetBounds(0, 1, 0, 1, 0, 1);
mapper->SetInputConnection(cube->GetOutputPort());
mapper->Update();
d->m_Cube->SetMapper(mapper);
d->m_Cube->GetProperty()->SetRepresentationToWireframe();
d->m_Cube->GetProperty()->SetAmbient(0.7);
// AXES //
vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
axes->SetOrigin(0, 0, 0);
mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(d->m_AxesSource->GetOutputPort());
mapper->SetInputConnection(axes->GetOutputPort());
mapper->Update();
d->m_Axes->SetMapper(mapper);
d->m_Axes->GetProperty()->SetLineWidth(3);
d->m_Axes->GetProperty()->SetAmbient(0.4);
d->m_Axes->GetProperty()->SetSpecular(0);
// PIVOT //
axes = vtkSmartPointer<vtkAxes>::New();
axes->SetOrigin(0, 0, 0);
mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(axes->GetOutputPort());
mapper->Update();
d->m_VtkAsm->AddPart(d->m_Cube);
d->m_VtkAsm->AddPart(d->m_Axes);
this->SetProp(d->m_VtkAsm);
// vtkProp3D* root = d->m_VtkAsm;
// if (root) {
// this->ApplyProp3DTransform(root);
// }
this->Update();
}

2
src/Vtk/Math/vtkContainerBox.h
View File

@@ -59,7 +59,7 @@ public:
/**
* @brief Synchronizes the model from the VTK representation (VTK→model).
*/
virtual void SyncFromVtk() override;
virtual uLib::Object *GetContent() const override {
return (uLib::Object *)m_model.get();

20
src/Vtk/Math/vtkCylinder.cpp
View File

@@ -44,8 +44,7 @@ Cylinder::Cylinder(Cylinder::Content *content)
}
Cylinder::~Cylinder() {
if (m_Actor) m_Actor->Delete();
if (m_VtkAsm) m_VtkAsm->Delete();
m_UpdateSignal.disconnect();
}
void Cylinder::Update() {
@@ -85,26 +84,13 @@ void Cylinder::Update() {
this->Prop3D::Update();
}
void Cylinder::SyncFromVtk() {
if (!this->m_model) return;
vtkProp3D* root = this->GetProxyProp();
if (!root) return;
// VTK -> Model: Extract new world TRS from proxy
vtkMatrix4x4* rootMat = root->GetUserMatrix();
Matrix4f vtkWorld = VtkToMatrix4f(rootMat);
// Directly sync model from the world matrix
this->m_model->FromMatrix(vtkWorld);
this->m_model->Updated();
}
void Cylinder::InstallPipe() {
if (!this->m_model)
return;
m_VtkAsm = ::vtkAssembly::New();
m_VtkAsm = vtkSmartPointer<::vtkAssembly>::New();
this->SetProp(m_VtkAsm);
vtkNew<vtkCylinderSource> cylinder;
@@ -112,7 +98,7 @@ void Cylinder::InstallPipe() {
cylinder->SetHeight(1.0);
cylinder->SetResolution(32);
m_Actor = vtkActor::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
vtkNew<vtkTransform> alignment;
m_Actor->SetUserTransform(alignment);

7
src/Vtk/Math/vtkCylinder.h
View File

@@ -30,6 +30,7 @@
#include "Math/Cylinder.h"
#include "Vtk/uLibVtkInterface.h"
#include <vtkActor.h>
#include <vtkSmartPointer.h>
class vtkAssembly;
namespace uLib {
@@ -53,7 +54,7 @@ public:
virtual void Update() override;
/** Synchronizes the uLib model matrix with the VTK actor specifically for gizmo interactions */
virtual void SyncFromVtk() override;
virtual uLib::Object *GetContent() const override {
return (uLib::Object *)m_model.get();
@@ -63,8 +64,8 @@ protected:
/** Sets up the VTK visualization pipeline */
virtual void InstallPipe();
vtkActor *m_Actor;
::vtkAssembly *m_VtkAsm;
vtkSmartPointer<vtkActor> m_Actor;
vtkSmartPointer<::vtkAssembly> m_VtkAsm;
uLib::Connection m_UpdateSignal;
};

12
src/Vtk/Math/vtkVoxImage.cpp
View File

@@ -308,17 +308,7 @@ void VoxImage::serialize_display(uLib::Archive::display_properties_archive & ar,
{"MIP", "Composite", "Composite Shaded", "MIP Bone", "MIP Hot", "Additive"});
}
void VoxImage::SyncFromVtk() {
if (auto *root = this->GetProxyProp()) {
vtkMatrix4x4 *rootMat = root->GetUserMatrix();
if (rootMat) {
Matrix4f vtkLocal = VtkToMatrix4f(rootMat);
// Synchronize TRS from VTK, compensating for local volume offset
this->m_model->FromMatrix(vtkLocal); // * this->m_model->GetLocalMatrix().inverse());
this->m_model->Updated();
}
}
}
void VoxImage::Update() {
if (auto *root = vtkProp3D::SafeDownCast(this->GetProp())) {

2
src/Vtk/Math/vtkVoxImage.h
View File

@@ -77,7 +77,7 @@ public:
void RescaleShaderRange();
void Update() override;
void SyncFromVtk() override;
void serialize_display(uLib::Archive::display_properties_archive &ar,
const unsigned int version = 0) override;

34
src/Vtk/uLibVtkInterface.cxx
View File

@@ -97,11 +97,24 @@ public:
m_HighlightMode(Prop3D::HighlightPlain)
{
m_Color = Vector3d(-1, -1, -1);
m_PrevMatrix = vtkSmartPointer<vtkMatrix4x4>::New();
m_PrevMatrix->Identity();
}
~Prop3DData() {
// No manual Delete needed for smart pointers
if (m_Renderers) {
m_Renderers->InitTraversal();
for (int i = 0; i < m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer* ren = m_Renderers->GetNextItem();
if (ren) {
if (m_Prop) ren->RemoveViewProp(m_Prop);
if (m_OutlineActor) ren->RemoveActor(m_OutlineActor);
if (m_CubeAxesActor) ren->RemoveActor(m_CubeAxesActor);
if (m_HighlightActor) ren->RemoveActor(m_HighlightActor);
}
}
m_Renderers->RemoveAllItems();
}
}
Prop3D *m_Prop3D;
@@ -128,6 +141,8 @@ public:
int m_HighlightMode; // 0: Plain, 1: Corners
vtkSmartPointer<vtkMatrix4x4> m_PrevMatrix;
//
TRS m_Transform;
@@ -289,6 +304,7 @@ public:
vtkNew<vtkMatrix4x4> vwm;
Matrix4fToVtk(tr->GetWorldMatrix(), vwm);
m_HighlightActor->SetUserMatrix(vwm);
m_PrevMatrix->DeepCopy(vwm);
}
}
}
@@ -620,6 +636,7 @@ void Prop3D::ApplyProp3DTransform(vtkProp3D* prop)
Matrix4fToVtk(tr->GetMatrix(), m);
prop->SetUserMatrix(m);
prop->Modified();
pd->m_PrevMatrix->DeepCopy(m);
}
}
}
@@ -630,7 +647,18 @@ void Prop3D::SyncFromVtk()
if (auto* tr = dynamic_cast<uLib::TRS*>(content)) {
if (auto* proxy = this->GetProxyProp()) {
if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
tr->FromMatrix(VtkToMatrix4f(mat));
// Calculate Delta: currentMatrix * Inv(m_PrevMatrix)
vtkNew<vtkMatrix4x4> invPrev;
vtkMatrix4x4::Invert(pd->m_PrevMatrix, invPrev);
vtkNew<vtkMatrix4x4> delta;
vtkMatrix4x4::Multiply4x4(mat, invPrev, delta);
// Apply delta to world matrix
Matrix4f nextWorldMatrix = VtkToMatrix4f(delta) * tr->GetWorldMatrix();
tr->SetWorldMatrix(nextWorldMatrix);
pd->m_PrevMatrix->DeepCopy(mat);
content->Updated();
}
}

37
src/Vtk/vtkObjectsContext.cpp
View File

@@ -6,7 +6,6 @@
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "Vtk/HEP/Geant/vtkBoxSolid.h"
#include "Vtk/HEP/Geant/vtkTessellatedSolid.h"
#include <cstring>
#include <iostream>
@@ -27,21 +26,17 @@ ObjectsContext::ObjectsContext(uLib::ObjectsContext *context)
: m_Context(context), m_Assembly(::vtkAssembly::New()) {
this->SetProp(m_Assembly);
if (m_Context) {
Object::connect(m_Context, &uLib::ObjectsContext::ObjectAdded, this,
m_AddedConnection = Object::connect(m_Context, &uLib::ObjectsContext::ObjectAdded, this,
&ObjectsContext::OnObjectAdded);
Object::connect(m_Context, &uLib::ObjectsContext::ObjectRemoved, this,
m_RemovedConnection = Object::connect(m_Context, &uLib::ObjectsContext::ObjectRemoved, this,
&ObjectsContext::OnObjectRemoved);
this->Synchronize();
}
}
ObjectsContext::~ObjectsContext() {
if (m_Context) {
Object::disconnect(m_Context, &uLib::ObjectsContext::ObjectAdded, this,
&ObjectsContext::OnObjectAdded);
Object::disconnect(m_Context, &uLib::ObjectsContext::ObjectRemoved, this,
&ObjectsContext::OnObjectRemoved);
}
m_AddedConnection.disconnect();
m_RemovedConnection.disconnect();
for (auto const &[obj, prop3d] : m_Prop3Ds) {
delete prop3d;
}
@@ -55,8 +50,8 @@ void ObjectsContext::Synchronize() {
// 1. Identify objects to add and remove
const auto &objects = m_Context->GetObjects();
std::map<uLib::Object *, bool> currentObjects;
for (const auto& obj : objects)
currentObjects[obj.get()] = true;
for (auto obj : objects)
currentObjects[obj] = true;
// Remove Prop3Ds for objects no longer in context
for (auto it = m_Prop3Ds.begin(); it != m_Prop3Ds.end();) {
@@ -77,11 +72,11 @@ void ObjectsContext::Synchronize() {
}
// Add Prop3Ds for new objects
for (const auto& obj : objects) {
if (m_Prop3Ds.find(obj.get()) == m_Prop3Ds.end()) {
Prop3D *prop3d = this->CreateProp3D(obj.get());
for (auto obj : objects) {
if (m_Prop3Ds.find(obj) == m_Prop3Ds.end()) {
Prop3D *prop3d = this->CreateProp3D(obj);
if (prop3d) {
m_Prop3Ds[obj.get()] = prop3d;
m_Prop3Ds[obj] = prop3d;
if (auto *p3d = vtkProp3D::SafeDownCast(prop3d->GetProp()))
m_Assembly->AddPart(p3d);
this->Prop3DAdded(prop3d);
@@ -157,20 +152,8 @@ Prop3D *ObjectsContext::CreateProp3D(uLib::Object *obj) {
return new Cylinder(cylinder);
} else if (auto *assembly = dynamic_cast<uLib::Assembly *>(obj)) {
return new Assembly(assembly);
} else if (auto *pv = dynamic_cast<uLib::Geant::PhysicalVolume *>(obj)) {
uLib::Geant::Solid *solid = pv->GetLogical()->GetSolid();
if (auto *box = dynamic_cast<uLib::Geant::BoxSolid *>(solid)) {
return new BoxSolid(pv);
} else if (auto *tess = dynamic_cast<uLib::Geant::TessellatedSolid *>(solid)) {
return new TessellatedSolid(pv);
} else {
return new GeantSolid(pv);
}
} else if (auto *box = dynamic_cast<uLib::Geant::BoxSolid *>(obj)) {
return new BoxSolid(box);
} else if (auto *solid = dynamic_cast<uLib::Geant::Solid *>(obj)) {
// Unplaced solid visualization
return new GeantSolid(solid);
}
// Fallback if we don't know the exact class but it might be a context itself

4
src/Vtk/vtkObjectsContext.h
View File

@@ -33,8 +33,6 @@ public:
/** @brief Synchronizes all managed prop3ds back to their models. */
virtual void SyncFromVtk() override;
virtual Object* GetContent() const override { return (Object*)m_Context; }
public:
virtual void Prop3DAdded(Prop3D* prop3d);
virtual void Prop3DRemoved(Prop3D* prop3d);
@@ -53,6 +51,8 @@ private:
uLib::ObjectsContext *m_Context;
std::map<uLib::Object*, Prop3D*> m_Prop3Ds;
vtkAssembly *m_Assembly;
uLib::Connection m_AddedConnection;
uLib::Connection m_RemovedConnection;
};
} // namespace Vtk

3
src/Vtk/vtkQViewport.cpp
View File

@@ -104,6 +104,9 @@ QViewport::QViewport(QWidget* parent)
QViewport::~QViewport()
{
if (m_VtkWidget && m_VtkWidget->renderWindow()) {
m_VtkWidget->renderWindow()->RemoveRenderer(this->GetRenderer());
}
}
void QViewport::SetupPipeline()

43
src/Vtk/vtkViewport.cpp
View File

@@ -123,9 +123,10 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
iren->SetInteractorStyle(style);
// Corner annotation
SetFontColor(Vector3d(1.0, 1.0, 1.0));
SetFont(FontConfig("Arial", 10));
pv->m_Annotation->GetTextProperty()->SetColor(1, 1, 1);
pv->m_Annotation->GetTextProperty()->SetFontFamilyToArial();
pv->m_Annotation->GetTextProperty()->SetOpacity(0.5);
pv->m_Annotation->SetMaximumFontSize(10);
pv->m_Annotation->SetText(0, "uLib VTK viewer.");
pv->m_Renderer->AddViewProp(pv->m_Annotation);
@@ -602,44 +603,6 @@ bool Viewport::GetParallelProjection() const
return false;
}
void Viewport::SetFont(const FontConfig& font) {
if (!pv->m_Annotation) return;
auto* prop = pv->m_Annotation->GetTextProperty();
if (font.family == "Arial") prop->SetFontFamilyToArial();
else if (font.family == "Courier") prop->SetFontFamilyToCourier();
else if (font.family == "Times") prop->SetFontFamilyToTimes();
else prop->SetFontFamilyToArial(); // fallback
pv->m_Annotation->SetMaximumFontSize(font.size);
prop->SetBold(font.bold);
prop->SetItalic(font.italic);
this->Render();
}
FontConfig Viewport::GetFont() const {
if (!pv->m_Annotation) return FontConfig();
auto* prop = pv->m_Annotation->GetTextProperty();
FontConfig f;
f.family = prop->GetFontFamilyAsString();
f.size = pv->m_Annotation->GetMaximumFontSize();
f.bold = prop->GetBold();
f.italic = prop->GetItalic();
return f;
}
void Viewport::SetFontColor(const Vector3d& color) {
if (!pv->m_Annotation) return;
pv->m_Annotation->GetTextProperty()->SetColor(color.x(), color.y(), color.z());
this->Render();
}
Vector3d Viewport::GetFontColor() const {
if (!pv->m_Annotation) return Vector3d(1,1,1);
double c[3];
pv->m_Annotation->GetTextProperty()->GetColor(c);
return Vector3d(c[0], c[1], c[2]);
}
void Viewport::SetGridAxis(Axis axis)
{
m_GridAxis = axis;

8
src/Vtk/vtkViewport.h
View File

@@ -4,8 +4,6 @@
#include "uLibVtkInterface.h"
#include <vector>
#include <map>
#include "Core/FontConfig.h"
#include "Math/Dense.h"
namespace uLib { class Object; }
@@ -85,12 +83,6 @@ public:
void SetParallelProjection(bool parallel);
bool GetParallelProjection() const;
// Font configuration
void SetFont(const FontConfig& font);
FontConfig GetFont() const;
void SetFontColor(const Vector3d& color);
Vector3d GetFontColor() const;
protected:
void SetupPipeline(vtkRenderWindowInteractor* iren);

56
src/Vtk/vtkViewportProperties.h
View File

@@ -1,56 +0,0 @@
#ifndef ULIB_VTK_VIEWPORTPROPERTIES_H
#define ULIB_VTK_VIEWPORTPROPERTIES_H
#include "uLibVtkInterface.h"
#include "vtkViewport.h"
#include "Core/Property.h"
namespace uLib {
namespace Vtk {
/**
* @class ViewportProperties
* @brief Exposes Viewport settings as a uLib::Object for the properties panel.
*/
class ViewportProperties : public uLib::Object {
public:
uLibTypeMacro(ViewportProperties, uLib::Object)
ViewportProperties(Viewport* vp) : m_Viewport(vp)
{
SetInstanceName("Viewport Settings");
// Initialize properties from viewport
Font.Set(vp->GetFont());
Color.Set(vp->GetFontColor());
GridVisible.Set(vp->GetGridVisible());
Parallel.Set(vp->GetParallelProjection());
// Connect properties to viewport setters
uLib::Object::connect(&Font, &Property<FontConfig>::Updated, [this](){
if (m_Viewport) m_Viewport->SetFont(Font.Get());
});
uLib::Object::connect(&Color, &Property<Vector3d>::Updated, [this](){
if (m_Viewport) m_Viewport->SetFontColor(Color.Get());
});
uLib::Object::connect(&GridVisible, &Property<bool>::Updated, [this](){
if (m_Viewport) m_Viewport->SetGridVisible(GridVisible.Get());
});
uLib::Object::connect(&Parallel, &Property<bool>::Updated, [this](){
if (m_Viewport) m_Viewport->SetParallelProjection(Parallel.Get());
});
}
ULIB_PROPERTY(FontConfig, Font, FontConfig())
ULIB_PROPERTY(Vector3d, Color, Vector3d(1.0, 1.0, 1.0))
ULIB_PROPERTY(bool, GridVisible, true)
ULIB_PROPERTY(bool, Parallel, false)
private:
Viewport* m_Viewport;
};
} // namespace Vtk
} // namespace uLib
#endif // ULIB_VTK_VIEWPORTPROPERTIES_H