From bbd7493d9f02b42810aa666976670d131d528bb7 Mon Sep 17 00:00:00 2001 From: AndreaRigoni Date: Sat, 21 Mar 2026 15:41:58 +0000 Subject: [PATCH] add QCanvas Root and viewport pane in gcompose --- CMakeLists.txt | 5 +- app/gcompose/CMakeLists.txt | 5 + app/gcompose/src/MainPanel.cpp | 49 +++++ app/gcompose/src/MainPanel.h | 22 +++ app/gcompose/src/MainWindow.cpp | 7 +- app/gcompose/src/MainWindow.h | 7 +- app/gcompose/src/QViewportPane.cpp | 169 ++++++++++++++++++ app/gcompose/src/QViewportPane.h | 34 ++++ app/gcompose/src/main.cpp | 27 +-- src/HEP/Detectors/DetectorChamber.cpp | 9 +- src/Root/CMakeLists.txt | 27 ++- src/Root/Makefile.am | 20 --- src/Root/QCanvas.cpp | 153 ++++++++++++++++ src/Root/QCanvas.h | 38 ++++ src/Root/testing/CMakeLists.txt | 6 + src/Root/testing/QCanvasTest.cpp | 46 +++++ src/Vtk/HEP/Detectors/testing/CMakeLists.txt | 1 + .../testing/vtkDetectorMuonProjectionTest.cpp | 156 ++++++++++++++++ src/Vtk/vtkViewport.h | 1 + 19 files changed, 721 insertions(+), 61 deletions(-) create mode 100644 app/gcompose/src/MainPanel.cpp create mode 100644 app/gcompose/src/MainPanel.h create mode 100644 app/gcompose/src/QViewportPane.cpp create mode 100644 app/gcompose/src/QViewportPane.h delete mode 100644 src/Root/Makefile.am create mode 100644 src/Root/QCanvas.cpp create mode 100644 src/Root/QCanvas.h create mode 100644 src/Root/testing/QCanvasTest.cpp create mode 100644 src/Vtk/HEP/Detectors/testing/vtkDetectorMuonProjectionTest.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 4173627..8ae740a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -157,7 +157,10 @@ else() GUISupportQt) endif() -find_package(Qt6 COMPONENTS Widgets REQUIRED) +find_package(Qt6 COMPONENTS Widgets) +if(Qt6_FOUND) + add_compile_definitions(HAVE_QT) +endif() find_package(Geant4) if(Geant4_FOUND) diff --git a/app/gcompose/CMakeLists.txt b/app/gcompose/CMakeLists.txt index cfaf492..af064d9 100644 --- a/app/gcompose/CMakeLists.txt +++ b/app/gcompose/CMakeLists.txt @@ -3,6 +3,10 @@ add_executable(gcompose src/main.cpp src/MainWindow.h src/MainWindow.cpp + src/QViewportPane.h + src/QViewportPane.cpp + src/MainPanel.h + src/MainPanel.cpp ) set_target_properties(gcompose PROPERTIES @@ -29,6 +33,7 @@ target_link_libraries(gcompose mutomMath mutomGeant mutomVtk + mutomRoot ${Geant4_LIBS_FILTERED} ${VTK_LIBRARIES} Qt6::Widgets diff --git a/app/gcompose/src/MainPanel.cpp b/app/gcompose/src/MainPanel.cpp new file mode 100644 index 0000000..dcc2fb9 --- /dev/null +++ b/app/gcompose/src/MainPanel.cpp @@ -0,0 +1,49 @@ +#include "MainPanel.h" +#include "QViewportPane.h" +#include +#include +#include +#include +#include + +MainPanel::MainPanel(QWidget* parent) : QWidget(parent) { + auto* mainLayout = new QVBoxLayout(this); + mainLayout->setContentsMargins(0, 0, 0, 0); + mainLayout->setSpacing(0); + + // 1. Top Menu Panel + auto* menuPanel = new QWidget(this); + menuPanel->setFixedHeight(36); + menuPanel->setStyleSheet("background-color: #2b2b2b; border-bottom: 1px solid #111;"); + + auto* menuLayout = new QHBoxLayout(menuPanel); + menuLayout->setContentsMargins(10, 0, 10, 0); + menuLayout->setSpacing(15); + + auto* logo = new QLabel("G-COMPOSE", menuPanel); + logo->setStyleSheet("font-weight: bold; color: #0078d7; font-size: 14px; letter-spacing: 1px;"); + + auto* btnOpen = new QPushButton("Open", menuPanel); + auto* btnSave = new QPushButton("Save", menuPanel); + + QString btnStyle = "QPushButton { background: transparent; color: #ccc; border: none; padding: 5px 10px; }" + "QPushButton:hover { background: #3c3c3c; color: white; border-radius: 4px; }"; + btnOpen->setStyleSheet(btnStyle); + btnSave->setStyleSheet(btnStyle); + + menuLayout->addWidget(logo); + menuLayout->addWidget(btnOpen); + menuLayout->addWidget(btnSave); + menuLayout->addStretch(); + + mainLayout->addWidget(menuPanel); + + // 2. Central Splitter Area + m_rootSplitter = new QSplitter(Qt::Horizontal, this); + m_firstPane = new QViewportPane(m_rootSplitter); + m_rootSplitter->addWidget(m_firstPane); + + mainLayout->addWidget(m_rootSplitter, 1); +} + +MainPanel::~MainPanel() {} diff --git a/app/gcompose/src/MainPanel.h b/app/gcompose/src/MainPanel.h new file mode 100644 index 0000000..ec46b56 --- /dev/null +++ b/app/gcompose/src/MainPanel.h @@ -0,0 +1,22 @@ +#ifndef MAINPANEL_H +#define MAINPANEL_H + +#include + +class QSplitter; +class QViewportPane; + +class MainPanel : public QWidget { + Q_OBJECT +public: + explicit MainPanel(QWidget* parent = nullptr); + virtual ~MainPanel(); + + QViewportPane* getFirstPane() const { return m_firstPane; } + +private: + QSplitter* m_rootSplitter; + QViewportPane* m_firstPane; +}; + +#endif // MAINPANEL_H diff --git a/app/gcompose/src/MainWindow.cpp b/app/gcompose/src/MainWindow.cpp index 10732b6..153ff4d 100644 --- a/app/gcompose/src/MainWindow.cpp +++ b/app/gcompose/src/MainWindow.cpp @@ -1,11 +1,12 @@ #include "MainWindow.h" -#include +#include +#include "MainPanel.h" using namespace uLib; MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) { - m_viewport = new Vtk::QViewport(this); - setCentralWidget(m_viewport); + m_panel = new MainPanel(this); + setCentralWidget(m_panel); setWindowTitle("gcompose - Qt VTK Interface"); resize(1200, 800); diff --git a/app/gcompose/src/MainWindow.h b/app/gcompose/src/MainWindow.h index 02dee89..0668f69 100644 --- a/app/gcompose/src/MainWindow.h +++ b/app/gcompose/src/MainWindow.h @@ -4,9 +4,10 @@ #include #include +class MainPanel; + namespace uLib { namespace Vtk { -class QViewport; } } @@ -16,10 +17,10 @@ public: MainWindow(QWidget* parent = nullptr); virtual ~MainWindow(); - uLib::Vtk::QViewport* getViewport() { return m_viewport; } + MainPanel* getPanel() { return m_panel; } private: - uLib::Vtk::QViewport* m_viewport; + MainPanel* m_panel; }; #endif diff --git a/app/gcompose/src/QViewportPane.cpp b/app/gcompose/src/QViewportPane.cpp new file mode 100644 index 0000000..7331101 --- /dev/null +++ b/app/gcompose/src/QViewportPane.cpp @@ -0,0 +1,169 @@ +#include "QViewportPane.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +QViewportPane::QViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullptr) { + m_layout = new QVBoxLayout(this); + m_layout->setContentsMargins(0, 0, 0, 0); + m_layout->setSpacing(0); + + // Title bar setup + m_titleBar = new QWidget(this); + m_titleBar->setFixedHeight(22); + m_titleBar->setStyleSheet("background-color: #333; color: white;"); + + auto* titleLayout = new QHBoxLayout(m_titleBar); + titleLayout->setContentsMargins(5, 0, 5, 0); + + m_titleLabel = new QLabel("Viewport", m_titleBar); + + auto* closeBtn = new QToolButton(m_titleBar); + closeBtn->setText("X"); + closeBtn->setFixedSize(18, 18); + closeBtn->setStyleSheet("QToolButton { border: none; font-weight: bold; background: transparent; color: #ccc; } " + "QToolButton:hover { color: white; background: red; }"); + + titleLayout->addWidget(m_titleLabel); + titleLayout->addStretch(); + titleLayout->addWidget(closeBtn); + + m_layout->addWidget(m_titleBar); + + m_titleBar->setContextMenuPolicy(Qt::CustomContextMenu); + connect(m_titleBar, &QWidget::customContextMenuRequested, this, &QViewportPane::showContextMenu); + connect(closeBtn, &QToolButton::clicked, this, &QViewportPane::onCloseRequested); + + addVtkViewport(); // Initialize with a default VTK 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"); +} + +void QViewportPane::addRootCanvas() { + auto* canvas = new uLib::Root::QCanvas(this); + setViewport(canvas, "ROOT Canvas"); +} + +void QViewportPane::onCloseRequested() { + QSplitter* parentSplitter = qobject_cast(parentWidget()); + if (parentSplitter && parentSplitter->count() > 1) { + deleteLater(); + } else { + // Can't close the last viewport in the splitter safely. Re-initialize to default VTK canvas. + addVtkViewport(); + } +} + +void QViewportPane::showContextMenu(const QPoint& pos) { + QMenu menu(this); + QAction* hSplit = menu.addAction("H split"); + QAction* vSplit = menu.addAction("V split"); + menu.addSeparator(); + + bool isVtk = (qobject_cast(m_viewport) != nullptr); + + QAction* changeType = menu.addAction(isVtk ? "Change to ROOT Canvas" : "Change to VTK Viewport"); + + QAction* selected = menu.exec(m_titleBar->mapToGlobal(pos)); + + if (selected == hSplit) { + AttemptSplit(Qt::Horizontal); + } else if (selected == vSplit) { + AttemptSplit(Qt::Vertical); + } else if (selected == changeType) { + if (isVtk) { + addRootCanvas(); + } else { + addVtkViewport(); + } + } +} + +void QViewportPane::AttemptSplit(Qt::Orientation orientation) { + QWidget* p = parentWidget(); + if (!p) return; + + QSplitter* parentSplitter = qobject_cast(p); + if (!parentSplitter) return; + + QViewportPane* newPane = new QViewportPane(); + + // 1. Synchronize viewport content and camera (VTK Viewport only for now) + auto* currentVtk = qobject_cast(m_viewport); + if (currentVtk) { + auto* newVtk = qobject_cast(newPane->currentViewport()); + if (newVtk) { + // Copy puppets + for (auto* puppet : currentVtk->getPuppets()) { + newVtk->AddPuppet(*puppet); + } + // Copy camera + if (currentVtk->GetRenderer() && newVtk->GetRenderer()) { + vtkCamera* currentCam = currentVtk->GetRenderer()->GetActiveCamera(); + vtkCamera* newCam = newVtk->GetRenderer()->GetActiveCamera(); + if (currentCam && newCam) { + newCam->DeepCopy(currentCam); + } + } + // Sync grid visible and axis + newVtk->SetGridVisible(currentVtk->GetGridVisible()); + newVtk->SetGridAxis(currentVtk->GetGridAxis()); + } + } + + // 2. Adjust for ROOT Canvas if that was the active view + bool isRoot = (qobject_cast(m_viewport) != nullptr); + if (isRoot) { + newPane->addRootCanvas(); + } + + if (parentSplitter->orientation() == orientation) { + int index = parentSplitter->indexOf(this); + QList sizes = parentSplitter->sizes(); + int currentSize = sizes.value(index, 0); + int half = currentSize / 2; + sizes[index] = half; + sizes.insert(index + 1, currentSize - half); + + parentSplitter->insertWidget(index + 1, newPane); + parentSplitter->setSizes(sizes); + } else { + int index = parentSplitter->indexOf(this); + QList parentSizes = parentSplitter->sizes(); + + QSplitter* newSplitter = new QSplitter(orientation); + newSplitter->addWidget(this); + newSplitter->addWidget(newPane); + + QList subSizes; + subSizes << 500 << 500; + newSplitter->setSizes(subSizes); + + parentSplitter->insertWidget(index, newSplitter); + parentSplitter->setSizes(parentSizes); + } +} diff --git a/app/gcompose/src/QViewportPane.h b/app/gcompose/src/QViewportPane.h new file mode 100644 index 0000000..d67791d --- /dev/null +++ b/app/gcompose/src/QViewportPane.h @@ -0,0 +1,34 @@ +#ifndef QVIEWPORTPANE_H +#define QVIEWPORTPANE_H + +#include + +class QVBoxLayout; +class QLabel; + +class QViewportPane : public QWidget { + Q_OBJECT +public: + explicit QViewportPane(QWidget* parent = nullptr); + virtual ~QViewportPane(); + + void addVtkViewport(); + void addRootCanvas(); + + QWidget* currentViewport() const { return m_viewport; } + +private slots: + void onCloseRequested(); + void showContextMenu(const QPoint& pos); + +private: + void AttemptSplit(Qt::Orientation orientation); + void setViewport(QWidget* viewport, const QString& title); + + QVBoxLayout* m_layout; + QWidget* m_titleBar; + QLabel* m_titleLabel; + QWidget* m_viewport; +}; + +#endif // QVIEWPORTPANE_H diff --git a/app/gcompose/src/main.cpp b/app/gcompose/src/main.cpp index afa7f68..392cdce 100644 --- a/app/gcompose/src/main.cpp +++ b/app/gcompose/src/main.cpp @@ -1,5 +1,7 @@ #include #include "MainWindow.h" +#include "MainPanel.h" +#include "QViewportPane.h" #include "Math/ContainerBox.h" #include @@ -27,19 +29,7 @@ int main(int argc, char** argv) { std::cout << "Starting gcompose Qt application..." << std::endl; ContainerBox world_box(Vector3f(1, 1, 1)); - world_box.Scale(Vector3f(20_mm, 20_mm, 20_mm)); - - DetectorChamber d1, d2; - d1.SetSize(Vector3f(1, 1, 1)); - d1.SetPosition(Vector3f(0, 0, 0)); - d1.Scale(Vector3f(5, 10, 2)); - d1.Translate(Vector3f(0, 0, 0)); - - d2.SetSize(Vector3f(1, 1, 1)); - d2.SetPosition(Vector3f(0, 0, 0)); - d2.Scale(Vector3f(5, 10, 2)); - d2.Translate(Vector3f(0, 0, 10)); - + world_box.Scale(Vector3f(20_mm, 20_mm, 20_mm)); Geant::Scene scene; scene.ConstructWorldBox(world_box.GetSize(), "G4_AIR"); @@ -47,17 +37,12 @@ int main(int argc, char** argv) { // 2. Initialize MainWindow (contains embedded VTK QViewport) MainWindow window; - Vtk::QViewport* viewport = window.getViewport(); - - Vtk::vtkDetectorChamber vtk_d1(&d1); - viewport->AddPuppet(vtk_d1); - - Vtk::vtkDetectorChamber vtk_d2(&d2); - viewport->AddPuppet(vtk_d2); + MainPanel* panel = window.getPanel(); + QViewportPane* pane = panel->getFirstPane(); + Vtk::QViewport* viewport = qobject_cast(pane->currentViewport()); Vtk::vtkContainerBox vtk_box(&world_box); viewport->AddPuppet(vtk_box); - viewport->ZoomAuto(); std::cout << "Geant4 and VTK scenes are ready." << std::endl; diff --git a/src/HEP/Detectors/DetectorChamber.cpp b/src/HEP/Detectors/DetectorChamber.cpp index 497d4b2..240a4fd 100644 --- a/src/HEP/Detectors/DetectorChamber.cpp +++ b/src/HEP/Detectors/DetectorChamber.cpp @@ -14,14 +14,7 @@ MuonEvent DetectorChamber::ProjectMuonEvent(const MuonEvent &muon) const { HPoint3f X_in = muon.LineIn().origin; HPoint3f X_out = muon.LineOut().origin; - // Calculate squared distances to the plane normal point for comparison - // Actually, we should probably follow the user's description literally: - // "closest ... with the projection plane ( so the colsest direction point with the point of the normal defining the plane )" - // This could mean point-to-plane or point-to-point. - // Given "closest with the projection plane", point-to-plane is more natural. - // However, "closest direction point with the point of the normal" strongly suggests point-to-point distance. - // Let's use distance to the plane for the first part and keep the logic consistent. - + // Let's use distance to the plane for the first part and keep the logic consistent. float dist_in = std::abs((X_in - P).dot(N)); float dist_out = std::abs((X_out - P).dot(N)); diff --git a/src/Root/CMakeLists.txt b/src/Root/CMakeLists.txt index 37143ff..9ad53e4 100644 --- a/src/Root/CMakeLists.txt +++ b/src/Root/CMakeLists.txt @@ -8,6 +8,9 @@ set(HEADERS RootMathDense.h muCastorPrimaryVertex.h muCastorMuDetDIGI.h SkinDetectorWriter.h) +if(Qt6_FOUND) + list(APPEND HEADERS QCanvas.h) +endif() set(SOURCES ${HEADERS} RootMuonScatter.cpp muCastorMCTrack.cpp @@ -17,6 +20,9 @@ set(SOURCES ${HEADERS} RootMuonScatter.cpp muCastorPrimaryVertex.cpp muCastorMuDetDIGI.cpp SkinDetectorWriter.cpp) +if(Qt6_FOUND) + list(APPEND SOURCES QCanvas.cpp) +endif() set(DICTIONARY_HEADERS muCastorMCTrack.h muCastorHit.h @@ -32,11 +38,17 @@ set(LIBRARIES ${ROOT_LIBRARIES} set(rDictName ${PACKAGE_LIBPREFIX}RootDict) root_generate_dictionary(${rDictName} ${DICTIONARY_HEADERS} LINKDEF Linkdef.h) -set_source_files_properties(${rDictName}.cxx - PROPERTIES GENERATED TRUE) -set_source_files_properties(${rDictName}.h - PROPERTIES GENERATED TRUE) -list(APPEND SOURCES ${rDictName}.cxx) +set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${rDictName}.cxx + PROPERTIES GENERATED TRUE + SKIP_AUTOMOC TRUE + SKIP_AUTOUIC TRUE + SKIP_AUTORCC TRUE) +set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${rDictName}.h + PROPERTIES GENERATED TRUE + SKIP_AUTOMOC TRUE + SKIP_AUTOUIC TRUE + SKIP_AUTORCC TRUE) +list(APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${rDictName}.cxx) # TODO use a custom target linked to root_generate_dictionary set(R_ARTIFACTS ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}_rdict.pcm @@ -55,6 +67,11 @@ set_target_properties(${libname} PROPERTIES CXX_STANDARD 17) target_link_libraries(${libname} ${LIBRARIES}) +if(Qt6_FOUND) + set_target_properties(${libname} PROPERTIES AUTOMOC ON) + target_link_libraries(${libname} Qt6::Widgets) +endif() + install(TARGETS ${libname} EXPORT "uLibTargets" RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin diff --git a/src/Root/Makefile.am b/src/Root/Makefile.am deleted file mode 100644 index 868c022..0000000 --- a/src/Root/Makefile.am +++ /dev/null @@ -1,20 +0,0 @@ -SUBDIRS = . - -ROOTCINT = `which rootcint` - -include $(top_srcdir)/Common.am - -library_includedir = $(includedir)/libmutom-${PACKAGE_VERSION}/Root - -library_include_HEADERS = TestTObject.h - - -_CORE_SOURCES = TestTObject.cpp - - -MutomDict.cxx: $(library_include_HEADERS) Linkdef.h - $(ROOTCINT) -f $@ -c $(AM_CXXFLAGS) -p $^ - - -noinst_LTLIBRARIES = libmutomroot.la -libmutomroot_la_SOURCES = MutomDict.cxx ${_CORE_SOURCES} diff --git a/src/Root/QCanvas.cpp b/src/Root/QCanvas.cpp new file mode 100644 index 0000000..a18100d --- /dev/null +++ b/src/Root/QCanvas.cpp @@ -0,0 +1,153 @@ +#include "QCanvas.h" +#include +#include + + + + + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace uLib { +namespace Root { + +QCanvas::QCanvas(QWidget *parent) : QWidget(parent), m_canvas(nullptr) { + if (gEnv) gEnv->SetValue("Canvas.UseDoubleBuffer", 0); + setMinimumSize(400, 300); + resize(400, 300); + setUpdatesEnabled(false); + setAttribute(Qt::WA_NativeWindow, true); + setAttribute(Qt::WA_OpaquePaintEvent, true); + setAttribute(Qt::WA_PaintOnScreen, true); + setMouseTracking(true); // Required so that TCanvas can get mouse hover events + + if (!gApplication) { + static int argc = 1; + static char* argv[] = {(char*)"App", nullptr}; + new TApplication("App", &argc, argv); + } + + // Create the TCanvas associated with this QWidget + m_canvas = nullptr; +} + +QCanvas::~QCanvas() { + delete m_canvas; +} + +void QCanvas::SetCanvas(TCanvas* c) { + m_canvas = c; +} + +void QCanvas::paintEvent(QPaintEvent* /*event*/) { + EnsureCanvasCreated(); + if (m_canvas) { + m_canvas->Update(); + } +} + +void QCanvas::resizeEvent(QResizeEvent* event) { + EnsureCanvasCreated(); + if (m_canvas) { + m_canvas->SetWindowSize(event->size().width(), event->size().height()); + m_canvas->Resize(); + m_canvas->Update(); + } +} + +TCanvas* QCanvas::GetCanvas() { + EnsureCanvasCreated(); + return m_canvas; +} + +void QCanvas::EnsureCanvasCreated() { + if (!m_canvas) { + WId wid = this->winId(); + std::cout << "DEBUG: QCanvas winId: " << wid << " (hex: 0x" << std::hex << wid << std::dec << ")" << std::endl; + + if (gSystem) gSystem->ProcessEvents(); + + // Ensure backend is loaded before creating the embedded canvas + if (!gVirtualX) { + TCanvas dummy("dummy", "dummy", 10, 10); + } + + // Add the X11 window to ROOT's window table and get its internal ROOT index. + Int_t root_wid = -1; + if (gVirtualX) { + root_wid = gVirtualX->AddWindow((ULongptr_t)wid, (UInt_t)width(), (UInt_t)height()); + } + + char name[100]; + sprintf(name, "RootQCanvas_%p", (void*)this); + m_canvas = new TCanvas(name, (Int_t)width(), (Int_t)height(), root_wid); + } +} + +void QCanvas::mouseMoveEvent(QMouseEvent* event) { + if (m_canvas) { + auto pos = event->position(); + if (event->buttons() & Qt::LeftButton) { + m_canvas->HandleInput(kButton1Motion, pos.x(), pos.y()); + } else if (event->buttons() & Qt::MiddleButton) { + m_canvas->HandleInput(kButton2Motion, pos.x(), pos.y()); + } else if (event->buttons() & Qt::RightButton) { + m_canvas->HandleInput(kButton3Motion, pos.x(), pos.y()); + } else { + m_canvas->HandleInput(kMouseMotion, pos.x(), pos.y()); + } + } +} + +void QCanvas::mousePressEvent(QMouseEvent* event) { + if (m_canvas) { + auto pos = event->position(); + switch (event->button()) { + case Qt::LeftButton: + m_canvas->HandleInput(kButton1Down, pos.x(), pos.y()); + break; + case Qt::RightButton: + m_canvas->HandleInput(kButton3Down, pos.x(), pos.y()); + break; + case Qt::MiddleButton: + m_canvas->HandleInput(kButton2Down, pos.x(), pos.y()); + break; + default: + break; + } + } +} + +void QCanvas::mouseReleaseEvent(QMouseEvent* event) { + if (m_canvas) { + auto pos = event->position(); + switch (event->button()) { + case Qt::LeftButton: + m_canvas->HandleInput(kButton1Up, pos.x(), pos.y()); + break; + case Qt::RightButton: + m_canvas->HandleInput(kButton3Up, pos.x(), pos.y()); + break; + case Qt::MiddleButton: + m_canvas->HandleInput(kButton2Up, pos.x(), pos.y()); + break; + default: + break; + } + } +} + +} // namespace Root +} // namespace uLib + + diff --git a/src/Root/QCanvas.h b/src/Root/QCanvas.h new file mode 100644 index 0000000..643ef13 --- /dev/null +++ b/src/Root/QCanvas.h @@ -0,0 +1,38 @@ +#pragma once + +#ifdef HAVE_QT +#include + +class TCanvas; +class QPaintEvent; +class QResizeEvent; +class QMouseEvent; + +namespace uLib { +namespace Root { + +class QCanvas : public QWidget { + Q_OBJECT +public: + explicit QCanvas(QWidget *parent = nullptr); + virtual ~QCanvas(); + + TCanvas* GetCanvas(); + void SetCanvas(TCanvas* c); + +protected: + void paintEvent(QPaintEvent* event) override; + void resizeEvent(QResizeEvent* event) override; + void mouseMoveEvent(QMouseEvent* event) override; + void mousePressEvent(QMouseEvent* event) override; + void mouseReleaseEvent(QMouseEvent* event) override; + +private: + void EnsureCanvasCreated(); + TCanvas* m_canvas; +}; + +} // namespace Root +} // namespace uLib + +#endif // HAVE_QT \ No newline at end of file diff --git a/src/Root/testing/CMakeLists.txt b/src/Root/testing/CMakeLists.txt index 180d89a..2e22e93 100644 --- a/src/Root/testing/CMakeLists.txt +++ b/src/Root/testing/CMakeLists.txt @@ -3,6 +3,9 @@ set( TESTS # RootDebugTest # muBlastMCTrackTest ) +if(Qt6_FOUND) + list(APPEND TESTS QCanvasTest) +endif() set(LIBRARIES ${PACKAGE_LIBPREFIX}Core @@ -12,4 +15,7 @@ set(LIBRARIES Boost::program_options ${ROOT_LIBRARIES} ) +if(Qt6_FOUND) + list(APPEND LIBRARIES Qt6::Widgets) +endif() uLib_add_tests(Root) diff --git a/src/Root/testing/QCanvasTest.cpp b/src/Root/testing/QCanvasTest.cpp new file mode 100644 index 0000000..6f90629 --- /dev/null +++ b/src/Root/testing/QCanvasTest.cpp @@ -0,0 +1,46 @@ +#ifdef HAVE_QT +#include +#include +#include +#include +#include +#include +#include +#include "Root/QCanvas.h" + +int main(int argc, char **argv) { + if (gEnv) gEnv->SetValue("Canvas.UseDoubleBuffer", 0); + QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings); + QApplication app(argc, argv); + + QMainWindow mainWindow; + mainWindow.setWindowTitle("uLib Root QCanvas Test"); + + // Create our custom Root QCanvas widget + uLib::Root::QCanvas *qcanvas = new uLib::Root::QCanvas(&mainWindow); + mainWindow.setCentralWidget(qcanvas); + mainWindow.resize(800, 600); + mainWindow.show(); + app.processEvents(); + + // Now let's draw something in the ROOT canvas + TCanvas *canvas = qcanvas->GetCanvas(); + if (canvas) { + canvas->cd(); + TH1F *h1 = new TH1F("h1", "Test Histogram;X-axis;Events", 100, -5, 5); + h1->FillRandom("gaus", 10000); + h1->SetFillColor(kBlue-10); + h1->Draw(); + canvas->Modified(); + canvas->Update(); + app.processEvents(); + } else { + std::cerr << "FAIL: Canvas is still NULL after show() and processEvents()" << std::endl; + } + + return app.exec(); +} +#else +int main() { return 0; } +#endif + diff --git a/src/Vtk/HEP/Detectors/testing/CMakeLists.txt b/src/Vtk/HEP/Detectors/testing/CMakeLists.txt index 8364108..21b09da 100644 --- a/src/Vtk/HEP/Detectors/testing/CMakeLists.txt +++ b/src/Vtk/HEP/Detectors/testing/CMakeLists.txt @@ -2,6 +2,7 @@ set(TESTS vtkMuonScatterTest vtkDetectorChamberTest + vtkDetectorMuonProjectionTest ) set(LIBRARIES diff --git a/src/Vtk/HEP/Detectors/testing/vtkDetectorMuonProjectionTest.cpp b/src/Vtk/HEP/Detectors/testing/vtkDetectorMuonProjectionTest.cpp new file mode 100644 index 0000000..dc2dbd0 --- /dev/null +++ b/src/Vtk/HEP/Detectors/testing/vtkDetectorMuonProjectionTest.cpp @@ -0,0 +1,156 @@ +/*////////////////////////////////////////////////////////////////////////////// +// 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 "HEP/Detectors/DetectorChamber.h" +#include "HEP/Detectors/MuonScatter.h" +#include "Math/Units.h" +#include "Vtk/HEP/Detectors/vtkDetectorChamber.h" +#include "Vtk/HEP/Detectors/vtkMuonScatter.h" +#include "Vtk/uLibVtkViewer.h" + +#include +#include +#include +#include +#include +#include + +#define BOOST_TEST_MODULE vtkDetectorMuonProjectionTest +#include + +using namespace uLib; + +// A simple puppet class to represent an arrow indicative of a projected muon hit +class vtkArrowPuppet : public Vtk::Puppet { +public: + vtkArrowPuppet() : m_Actor(vtkActor::New()) { + vtkNew arrow; + vtkNew mapper; + mapper->SetInputConnection(arrow->GetOutputPort()); + m_Actor->SetMapper(mapper); + this->SetProp(m_Actor); + m_Actor->GetProperty()->SetColor(1, 1, 0); // Yellow color for visibility + } + + virtual ~vtkArrowPuppet() { m_Actor->Delete(); } + + void SetProjection(const HLine3f &line) { + HPoint3f p = line.origin; + HVector3f d = line.direction; + d.normalize(); + + vtkNew t; + t->Translate(p.x(), p.y(), p.z()); + + // vtkArrowSource initially points along X+ (1, 0, 0) + double vtk_x[3] = {1, 0, 0}; + double vtk_d[3] = {d.x(), d.y(), d.z()}; + + double axis[3]; + vtkMath::Cross(vtk_x, vtk_d, axis); + double dot = vtkMath::Dot(vtk_x, vtk_d); + double angle = vtkMath::DegreesFromRadians(acos(dot)); + + // Handle parallel or anti-parallel cases + if (vtkMath::Norm(axis) < 1e-6) { + if (dot < 0) { + t->RotateY(180); // Reverse direction if anti-parallel + } + } else { + t->RotateWXYZ(angle, axis); + } + + t->Scale(100, 100, 100); // Scale the arrow for visual prominence + m_Actor->SetUserTransform(t); + } + +private: + vtkActor *m_Actor; +}; + +BOOST_AUTO_TEST_CASE(vtkDetectorMuonProjectionTest) { + using namespace uLib::literals; + + // 1. Prepare a scene with two detector chambers + DetectorChamber d1, d2; + d1.Scale(Vector3f(1_m, 1_m, 10_cm)); + d1.Translate(Vector3f(0, 0, -0.5_m)); + + + d2.Scale(Vector3f(1_m, 1_m, 10_cm)); + d2.Translate(Vector3f(0, 0, 0.5_m)); + + // 2. Setup a muon event that crosses the detectors + MuonScatter event; + // Set an origin slightly offset and point it toward (0,0,0) + HPoint3f mu_origin(20_cm, 30_cm, -1_m); + event.LineIn().origin = mu_origin; + + // Direction is toward (0,0,0) + HVector3f mu_dir = (HPoint3f(0,0,0) - mu_origin); + mu_dir.normalize(); + event.LineIn().direction = mu_dir; + + // Let's make the track continue straight for a simple projection test + event.LineOut().origin = mu_origin - mu_dir * 3_m; + event.LineOut().direction = -mu_dir; + + MuonEvent mu_event; + mu_event.LineIn() = event.LineIn(); + mu_event.LineOut() = event.LineOut(); + + // 3. Project the muon on each detector to find the projection points + MuonEvent mu_proj1 = d1.ProjectMuonEvent(mu_event); + MuonEvent mu_proj2 = d2.ProjectMuonEvent(mu_event); + + Vtk::vtkDetectorChamber v_d1(&d1); + Vtk::vtkDetectorChamber v_d2(&d2); + Vtk::vtkMuonScatter v_event(event); + v_event.AddPocaPoint(HPoint3f(0, 0, 0)); + v_event.SetColor(1, 0, 0); // Red muon event + + v_d1.SetRepresentation(Vtk::Puppet::Surface); + v_d1.SetOpacity(0.3); + v_d2.SetRepresentation(Vtk::Puppet::Surface); + v_d2.SetOpacity(0.3); + + // 5. Add two arrows to mark where the projection is located on the chambers + vtkArrowPuppet v_p1, v_p2; + v_p1.SetProjection(mu_proj1.LineIn()); + v_p2.SetProjection(mu_proj2.LineIn()); + + if (std::getenv("CTEST_PROJECT_NAME") == nullptr) { + Vtk::Viewer viewer; + viewer.SetGridAxis(Vtk::Viewport::Z); + viewer.AddPuppet(v_d1); + viewer.AddPuppet(v_d2); + viewer.AddPuppet(v_event); + viewer.AddPuppet(v_p1); + viewer.AddPuppet(v_p2); + viewer.Start(); + } + + BOOST_CHECK(true); +} diff --git a/src/Vtk/vtkViewport.h b/src/Vtk/vtkViewport.h index bb488d4..65d41a4 100644 --- a/src/Vtk/vtkViewport.h +++ b/src/Vtk/vtkViewport.h @@ -61,6 +61,7 @@ public: virtual vtkRenderWindowInteractor* GetInteractor() = 0; vtkCornerAnnotation* GetAnnotation() { return m_Annotation; } vtkCameraOrientationWidget* GetCameraWidget(){ return m_CameraWidget; } + const std::vector& getPuppets() const { return m_Puppets; } // Grid control void SetGridVisible(bool visible);