add Qt viewport

CMakeLists.txt

@@ -9,6 +9,8 @@ endif()
 
 cmake_minimum_required (VERSION 3.26)
 
+set(QT_NO_VERSION_CHECK TRUE)
+
 if(POLICY CMP0167)
     cmake_policy(SET CMP0167 NEW)
 endif()
@@ -125,18 +127,12 @@ find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
 
 find_package(VTK REQUIRED)
-# include(${VTK_USE_FILE})
-
-set(GEANT4_USE_HDF5 OFF CACHE BOOL "Use HDF5" FORCE)
-find_package(Geant4 REQUIRED)
-
 find_package(pybind11 REQUIRED)
 
-
 option(CENTOS_SUPPORT "VTK definitions for CentOS" OFF)
 if(CENTOS_SUPPORT)
     find_package(VTK CONFIG REQUIRED)
-    include(${VTK_USE_FILE})
+    # include(${VTK_USE_FILE})
 else()
     find_package(VTK REQUIRED
                      COMPONENTS CommonColor
@@ -157,7 +153,25 @@ else()
                                 RenderingGL2PSOpenGL2
                                 RenderingOpenGL2
                                 RenderingVolumeOpenGL2
-                                 IOGeometry)
+                                IOGeometry
+                                GUISupportQt)
+endif()
+
+find_package(Qt6 COMPONENTS Widgets REQUIRED)
+
+find_package(Geant4 REQUIRED)
+message(STATUS "Geant4 libs: ${Geant4_LIBRARIES}")
+
+# Sanitize Geant4 targets to remove Qt5 dependencies that conflict with VTK/Qt6
+if(TARGET Geant4::G4interfaces)
+    set_target_properties(Geant4::G4interfaces PROPERTIES 
+        INTERFACE_LINK_LIBRARIES "Geant4::G4global;Geant4::G4graphics_reps;Geant4::G4intercoms"
+    )
+endif()
+if(TARGET Geant4::G4OpenGL)
+    set_target_properties(Geant4::G4OpenGL PROPERTIES 
+        INTERFACE_LINK_LIBRARIES "Geant4::G4vis_management;Geant4::G4graphics_reps;Geant4::G4geometry;Geant4::G4materials;Geant4::G4intercoms;Geant4::G4global;OpenGL::GL;OpenGL::GLU"
+    )
 endif()
 
 set(CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_INCLUDES math.h)

app/gcompose/CMakeLists.txt

@@ -1,5 +1,15 @@
 
-add_executable(gcompose src/main.cpp)
+add_executable(gcompose 
+    src/main.cpp
+    src/MainWindow.h
+    src/MainWindow.cpp
+)
+
+set_target_properties(gcompose PROPERTIES
+    AUTOMOC ON
+    AUTOUIC ON
+    AUTORCC ON
+)
 
 target_include_directories(gcompose PRIVATE 
     ${SRC_DIR}
@@ -8,13 +18,21 @@ target_include_directories(gcompose PRIVATE
     ${VTK_INCLUDE_DIRS}
 )
 
+# Filter Geant4 libraries to remove Qt-dependent ones
+set(Geant4_LIBS_FILTERED ${Geant4_LIBRARIES})
+if(Geant4_LIBS_FILTERED)
+    list(REMOVE_ITEM Geant4_LIBS_FILTERED Geant4::G4interfaces Geant4::G4OpenGL Geant4::G4visQt3D)
+endif()
+
 target_link_libraries(gcompose
     mutomCore
     mutomMath
     mutomGeant
     mutomVtk
-    ${Geant4_LIBRARIES}
+    ${Geant4_LIBS_FILTERED}
     ${VTK_LIBRARIES}
+    Qt6::Widgets
+    VTK::GUISupportQt
 )
 
 install(TARGETS gcompose RUNTIME DESTINATION bin)

app/gcompose/src/MainWindow.cpp

@@ -0,0 +1,15 @@
+#include "MainWindow.h"
+#include <Vtk/vtkQViewport.h>
+
+using namespace uLib;
+
+MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
+    m_viewport = new Vtk::QViewport(this);
+    setCentralWidget(m_viewport);
+
+    setWindowTitle("gcompose - Qt VTK Interface");
+    resize(1200, 800);
+}
+
+MainWindow::~MainWindow() {
+}

app/gcompose/src/MainWindow.h

@@ -0,0 +1,25 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QVTKOpenGLNativeWidget.h>
+
+namespace uLib {
+namespace Vtk {
+class QViewport;
+}
+}
+
+class MainWindow : public QMainWindow {
+    Q_OBJECT
+public:
+    MainWindow(QWidget* parent = nullptr);
+    virtual ~MainWindow();
+
+    uLib::Vtk::QViewport* getViewport() { return m_viewport; }
+
+private:
+    uLib::Vtk::QViewport* m_viewport;
+};
+
+#endif

app/gcompose/src/main.cpp

@@ -1,9 +1,13 @@
+#include <QApplication>
+#include "MainWindow.h"
 
 #include "Math/ContainerBox.h"
 #include <HEP/Geant/Scene.h>
+#include "HEP/Detectors/DetectorChamber.h"
+#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
 
-#include <Vtk/uLibVtkViewer.h>
 #include <Vtk/vtkContainerBox.h>
+#include <Vtk/vtkQViewport.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkCubeSource.h>
@@ -11,35 +15,53 @@
 #include <vtkActor.h>
 #include <vtkRenderer.h>
 
+
+#include "Math/Units.h"
 #include <iostream>
 
 using namespace uLib;
+using namespace uLib::literals;
 
 int main(int argc, char** argv) {
-    std::cout << "Starting gcompose application..." << std::endl;
+    QApplication app(argc, argv);
+    std::cout << "Starting gcompose Qt application..." << std::endl;
 
-    uLib::ContainerBox world_box(Vector3f(100, 100, 100));
+    ContainerBox world_box(Vector3f(1, 1, 1));
+    world_box.Scale(Vector3f(20_mm, 20_mm, 20_mm));
 
-    uLib::Scene scene;
+    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));
+    
+
+    Scene scene;
     scene.ConstructWorldBox(&world_box, "G4_AIR");
     scene.Initialize();
 
-    // 2. Initialize VTK Viewer
-    Vtk::Viewer viewer;
+    // 2. Initialize MainWindow (contains embedded VTK QViewport)
+    MainWindow window;
+    Vtk::QViewport* viewport = window.getViewport();
 
-    uLib::Vtk::vtkContainerBox vtk_box(&world_box);
-    viewer.AddPuppet(vtk_box);
+    Vtk::vtkDetectorChamber vtk_d1(&d1);
+    viewport->AddPuppet(vtk_d1);
 
-    viewer.GetRenderer()->Render();
+    Vtk::vtkDetectorChamber vtk_d2(&d2);
+    viewport->AddPuppet(vtk_d2);
+
+    Vtk::vtkContainerBox vtk_box(&world_box);
+    viewport->AddPuppet(vtk_box);
+
+    viewport->ZoomAuto();
 
     std::cout << "Geant4 and VTK scenes are ready." << std::endl;
-    std::cout << "Starting VTK Interactor..." << std::endl;
-
-    // 3. Start VTK interactor (blocks until window is closed)
-    viewer.Start();
-
-    // 4. Clean up
-    std::cout << "Shutting down..." << std::endl;
-
-    return 0;
+    
+    window.show();
+    return app.exec();
 }

src/Core/Debug.h

@@ -119,8 +119,8 @@ public:
     void AddAdapter(AdapterInterface &ad) { m_a.push_back(Adapter(ad)); }
 
     void Update() {
-        foreach(Adapter &ad, m_a) {
-            foreach(DItem &item, m_v) {
+        for(Adapter &ad : m_a) {
+            for(DItem &item : m_v) {
                 item.m_adapter->operator()(ad, item.m_value);
             }
         }

src/HEP/Geant/CMakeLists.txt

@@ -45,7 +45,16 @@ target_link_libraries(${libname}
     ${PACKAGE_LIBPREFIX}Core
     ${PACKAGE_LIBPREFIX}Math
     ${PACKAGE_LIBPREFIX}Detectors
-    ${Geant4_LIBRARIES}
+)
+
+# Filter Geant4 libraries to remove Qt-dependent ones
+set(Geant4_LIBS_FILTERED ${Geant4_LIBRARIES})
+if(Geant4_LIBS_FILTERED)
+    list(REMOVE_ITEM Geant4_LIBS_FILTERED Geant4::G4interfaces Geant4::G4OpenGL Geant4::G4visQt3D)
+endif()
+
+target_link_libraries(${libname}
+    ${Geant4_LIBS_FILTERED}
 )
 
 install(TARGETS ${libname}

src/HEP/Geant/Solid.cpp

@@ -24,6 +24,7 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 // G4 Solid //
+#include <CLHEP/Units/SystemOfUnits.h>
 #include <Geant4/G4LogicalVolume.hh>
 #include <Geant4/G4Material.hh>
 #include <Geant4/G4NistManager.hh>
@@ -43,11 +44,13 @@
 
 namespace uLib {
 
-class DetectorsSolidPimpl {
+class DetectorsSolidImpl {
 public:
   static G4ThreeVector getG4Vector3f(const Vector3f &vector) {
     return G4ThreeVector(vector(0), vector(1), vector(2));
   }
+
+  
 };
 
 Solid::Solid()
@@ -139,9 +142,9 @@ void TessellatedSolid::SetMesh(TriangleMesh &mesh) {
   for (int i = 0; i < mesh.Triangles().size(); ++i) {
     const Vector3i &trg = mesh.Triangles().at(i);
     G4TriangularFacet *facet = new G4TriangularFacet(
-        DetectorsSolidPimpl::getG4Vector3f(mesh.Points().at(trg(0))),
-        DetectorsSolidPimpl::getG4Vector3f(mesh.Points().at(trg(1))),
-        DetectorsSolidPimpl::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);
   }
   this->m_Logical->SetSolid(ts);

src/HEP/Geant/Solid.h

@@ -47,7 +47,7 @@ public:
 
   void SetNistMaterial(const char *name);
   void SetMaterial(G4Material *material);
-
+  void SetSizeUnit(const char *unit);
   // Implementiamo SetParent qui, per tutti.
   virtual void SetParent(Solid *parent); 
 
@@ -65,7 +65,6 @@ protected:
   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
 };

src/Math/Units.h

@@ -0,0 +1,51 @@
+#ifndef ULIB_MATH_UNITS_H
+#define ULIB_MATH_UNITS_H
+
+
+#include <CLHEP/Units/SystemOfUnits.h>
+
+namespace uLib {
+  using namespace CLHEP;
+
+  inline namespace literals {
+    constexpr double operator"" _m(long double v) { return static_cast<double>(v) * CLHEP::meter; }
+    constexpr double operator"" _cm(long double v) { return static_cast<double>(v) * CLHEP::centimeter; }
+    constexpr double operator"" _mm(long double v) { return static_cast<double>(v) * CLHEP::millimeter; }
+    constexpr double operator"" _um(long double v) { return static_cast<double>(v) * CLHEP::micrometer; }
+    constexpr double operator"" _nm(long double v) { return static_cast<double>(v) * CLHEP::nanometer; }
+    constexpr double operator"" _km(long double v) { return static_cast<double>(v) * CLHEP::kilometer; }
+
+    constexpr double operator"" _m(unsigned long long v) { return static_cast<double>(v) * CLHEP::meter; }
+    constexpr double operator"" _cm(unsigned long long v) { return static_cast<double>(v) * CLHEP::centimeter; }
+    constexpr double operator"" _mm(unsigned long long v) { return static_cast<double>(v) * CLHEP::millimeter; }
+    constexpr double operator"" _um(unsigned long long v) { return static_cast<double>(v) * CLHEP::micrometer; }
+    constexpr double operator"" _nm(unsigned long long v) { return static_cast<double>(v) * CLHEP::nanometer; }
+    constexpr double operator"" _km(unsigned long long v) { return static_cast<double>(v) * CLHEP::kilometer; }
+
+    constexpr double operator"" _deg(long double v) { return static_cast<double>(v) * CLHEP::degree; }
+    constexpr double operator"" _rad(long double v) { return static_cast<double>(v) * CLHEP::radian; }
+    constexpr double operator"" _deg(unsigned long long v) { return static_cast<double>(v) * CLHEP::degree; }
+    constexpr double operator"" _rad(unsigned long long v) { return static_cast<double>(v) * CLHEP::radian; }
+
+    constexpr double operator"" _ns(long double v) { return static_cast<double>(v) * CLHEP::nanosecond; }
+    constexpr double operator"" _s(long double v) { return static_cast<double>(v) * CLHEP::second; }
+    constexpr double operator"" _ms(long double v) { return static_cast<double>(v) * CLHEP::millisecond; }
+    constexpr double operator"" _ns(unsigned long long v) { return static_cast<double>(v) * CLHEP::nanosecond; }
+    constexpr double operator"" _s(unsigned long long v) { return static_cast<double>(v) * CLHEP::second; }
+    constexpr double operator"" _ms(unsigned long long v) { return static_cast<double>(v) * CLHEP::millisecond; }
+
+    constexpr double operator"" _MeV(long double v) { return static_cast<double>(v) * CLHEP::megaelectronvolt; }
+    constexpr double operator"" _eV(long double v) { return static_cast<double>(v) * CLHEP::electronvolt; }
+    constexpr double operator"" _keV(long double v) { return static_cast<double>(v) * CLHEP::kiloelectronvolt; }
+    constexpr double operator"" _GeV(long double v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
+    constexpr double operator"" _TeV(long double v) { return static_cast<double>(v) * CLHEP::teraelectronvolt; }
+    constexpr double operator"" _MeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::megaelectronvolt; }
+    constexpr double operator"" _eV(unsigned long long v) { return static_cast<double>(v) * CLHEP::electronvolt; }
+    constexpr double operator"" _keV(unsigned long long v) { return static_cast<double>(v) * CLHEP::kiloelectronvolt; }
+    constexpr double operator"" _GeV(unsigned long long v) { return static_cast<double>(v) * CLHEP::gigaelectronvolt; }
+  }
+}
+
+#endif
+
+

src/Math/testing/CMakeLists.txt

@@ -13,6 +13,7 @@ set(TESTS
         VoxImageCopyTest
         TriangleMeshTest
         BitCodeTest
+        UnitsTest
 )
 
 set(LIBRARIES

src/Math/testing/Makefile.am

@@ -14,7 +14,9 @@ TESTS = MathVectorTest  	\
 	PolicyTest		\
 	AccumulatorTest		\
 	VoxImageCopyTest	\
-	TriangleMeshTest
+	TriangleMeshTest	\
+	BitCodeTest		\
+	UnitsTest
 
 # else
 # TEST =

src/Math/testing/UnitsTest.cpp

@@ -0,0 +1,71 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 "testing-prototype.h"
+#include "Math/Units.h"
+#include <cmath>
+
+using namespace uLib;
+
+int main()
+{
+  BEGIN_TESTING(Math Units);
+
+  // Length
+  TEST0(1.0_m  != 1000.0);
+  TEST0(1_m    != 1000.0);
+  TEST0(1.0_cm != 10.0);
+  TEST0(1_cm   != 10.0);
+  TEST0(1.0_mm != 1.0);
+  TEST0(1_mm   != 1.0);
+  TEST0(1.0_km != 1000000.0);
+  TEST0(1_km   != 1000000.0);
+  TEST0(std::abs(1.0_um - 1e-3) > 1e-12);
+  TEST0(std::abs(1.0_nm - 1e-6) > 1e-15);
+
+  // Angle
+  TEST0(std::abs(180.0_deg - M_PI) > 1e-9);
+  TEST0(std::abs(180_deg - M_PI) > 1e-9);
+  TEST0(std::abs(1.0_rad - 1.0) > 1e-9);
+
+  // Time
+  TEST0(1.0_s  != 1e9);
+  TEST0(1_s    != 1e9);
+  TEST0(1.0_ms != 1e6);
+  TEST0(1_ms   != 1e6);
+  TEST0(1.0_ns != 1.0);
+  TEST0(1_ns   != 1.0);
+
+  // Energy
+  TEST0(1.0_MeV != 1.0);
+  TEST0(1_MeV   != 1.0);
+  TEST0(1.0_GeV != 1000.0);
+  TEST0(1_GeV   != 1000.0);
+  TEST0(1.0_TeV != 1000000.0);
+  TEST0(1.0_keV != 1e-3);
+  TEST0(1.0_eV  != 1e-6);
+
+  END_TESTING;
+}

src/Vtk/CMakeLists.txt

@@ -2,12 +2,14 @@ set(HEADERS uLibVtkInterface.h
             uLibVtkViewer.h
             vtkContainerBox.h
             vtkHandlerWidget.h
+            vtkQViewport.h
             )
 
 set(SOURCES uLibVtkInterface.cxx
             uLibVtkViewer.cpp
             vtkContainerBox.cpp
             vtkHandlerWidget.cpp
+            vtkQViewport.cpp
             )
 
 ## Pull in Math VTK wrappers (sets MATH_SOURCES / MATH_HEADERS)
@@ -42,9 +44,11 @@ set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Vtk PARENT_SCOPE)
 
 add_library(${libname} SHARED ${SOURCES})
 set_target_properties(${libname} PROPERTIES
-                      VERSION ${PROJECT_VERSION}
-                      SOVERSION ${PROJECT_SOVERSION})
-target_link_libraries(${libname} ${LIBRARIES})
+                                             SOVERSION ${PROJECT_SOVERSION}
+                       AUTOMOC ON
+                       AUTOUIC ON
+                       AUTORCC ON)
+target_link_libraries(${libname} ${LIBRARIES} Qt6::Widgets)
 
 install(TARGETS ${libname}
         EXPORT "uLibTargets"

src/Vtk/uLibVtkViewer.cpp

@@ -166,6 +166,8 @@ vtkCornerAnnotation *Viewer::GetAnnotation() { return m_Annotation; }
 
 vtkRenderer *Viewer::GetRenderer() { return m_Renderer; }
 
+vtkRenderWindow *Viewer::GetRenderWindow() { return m_RenderWindow; }
+
 vtkRenderWindowInteractor *Viewer::GetInteractor() {
   return m_RenderWindow->GetInteractor();
 }

src/Vtk/uLibVtkViewer.h

@@ -76,7 +76,7 @@ public:
   vtkCornerAnnotation *GetAnnotation();
 
   vtkRenderer *GetRenderer();
-
+  vtkRenderWindow *GetRenderWindow();
   vtkRenderWindowInteractor *GetInteractor();
 
   vtkCameraOrientationWidget *GetCameraWidget();

src/Vtk/vtkQViewport.cpp

@@ -0,0 +1,150 @@
+#include "vtkQViewport.h"
+
+#include <QVBoxLayout>
+
+#include <vtkAxesActor.h>
+#include <vtkCamera.h>
+#include <vtkCameraOrientationWidget.h>
+#include <vtkInteractorStyleTrackballCamera.h>
+#include <vtkObjectFactory.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkTextProperty.h>
+
+namespace uLib {
+namespace Vtk {
+
+QViewport::QViewport(QWidget* parent)
+    : QWidget(parent)
+    , m_VtkWidget(nullptr)
+    , m_Renderer(vtkRenderer::New())
+    , m_Annotation(vtkCornerAnnotation::New())
+    , m_Marker(vtkOrientationMarkerWidget::New())
+    , m_CameraWidget(nullptr)
+{
+    // Build the layout – zero margins so VTK fills the entire widget
+    auto* layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    m_VtkWidget = new QVTKOpenGLNativeWidget(this);
+    layout->addWidget(m_VtkWidget);
+
+    // After the Qt widget exists but before the first paint,
+    // attach the renderer and configure the pipeline.
+    SetupPipeline();
+}
+
+QViewport::~QViewport()
+{
+    m_Renderer->RemoveAllViewProps();
+    m_Renderer->Clear();
+
+    m_Annotation->Delete();
+    m_Marker->Delete();
+    if (m_CameraWidget)
+        m_CameraWidget->Delete();
+    m_Renderer->Delete();
+}
+
+void QViewport::SetupPipeline()
+{
+    // Add our renderer to the QVTKOpenGLNativeWidget's render window
+    vtkRenderWindow* rw = m_VtkWidget->renderWindow();
+    rw->AddRenderer(m_Renderer);
+
+    // Qt will supply its own interactor – grab it
+    vtkRenderWindowInteractor* iren = rw->GetInteractor();
+
+    // Trackball-camera interaction style
+    vtkNew<vtkInteractorStyleTrackballCamera> style;
+    iren->SetInteractorStyle(style);
+
+    // Corner annotation
+    m_Annotation->GetTextProperty()->SetColor(1, 1, 1);
+    m_Annotation->GetTextProperty()->SetFontFamilyToArial();
+    m_Annotation->GetTextProperty()->SetOpacity(0.5);
+    m_Annotation->SetMaximumFontSize(10);
+    m_Annotation->SetText(0, "uLib VTK Viewer - OpenCMT all right reserved.");
+    m_Renderer->AddViewProp(m_Annotation);
+
+    // Orientation axes marker (bottom-left corner)
+    vtkNew<vtkAxesActor> axes;
+    m_Marker->SetInteractor(iren);
+    m_Marker->SetOrientationMarker(axes);
+    m_Marker->SetViewport(0.0, 0.0, 0.2, 0.2);
+    m_Marker->SetEnabled(true);
+    m_Marker->InteractiveOff();
+
+    // Camera-orientation widget (VTK ≥ 9)
+#if VTK_MAJOR_VERSION >= 9
+    m_CameraWidget = vtkCameraOrientationWidget::New();
+    m_CameraWidget->SetParentRenderer(m_Renderer);
+    m_CameraWidget->SetInteractor(iren);
+    m_CameraWidget->On();
+#endif
+
+    m_Renderer->SetBackground(0.15, 0.15, 0.15);
+    m_Renderer->ResetCamera();
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+void QViewport::Render()
+{
+    m_VtkWidget->renderWindow()->Render();
+}
+
+void QViewport::Reset()
+{
+    ZoomAuto();
+    Render();
+}
+
+void QViewport::ZoomAuto()
+{
+    m_Renderer->ResetCameraClippingRange();
+    m_Renderer->ResetCamera();
+}
+
+void QViewport::AddPuppet(Puppet& prop)
+{
+    prop.ConnectRenderer(m_Renderer);
+    prop.ConnectInteractor(GetInteractor());
+    Render();
+}
+
+void QViewport::RemovePuppet(Puppet& prop)
+{
+    prop.DisconnectRenderer(m_Renderer);
+    Render();
+}
+
+void QViewport::addProp(vtkProp* prop)
+{
+    m_Renderer->AddActor(prop);
+    Render();
+}
+
+void QViewport::RemoveProp(vtkProp* prop)
+{
+    m_Renderer->RemoveViewProp(prop);
+    Render();
+}
+
+void QViewport::AddWidget(vtk3DWidget* /*widget*/)
+{
+    // vtk3DWidget integration can be added here if needed
+}
+
+vtkRenderWindow* QViewport::GetRenderWindow()
+{
+    return m_VtkWidget->renderWindow();
+}
+
+vtkRenderWindowInteractor* QViewport::GetInteractor()
+{
+    return m_VtkWidget->renderWindow()->GetInteractor();
+}
+
+} // namespace Vtk
+} // namespace uLib

src/Vtk/vtkQViewport.h

@@ -0,0 +1,69 @@
+#ifndef ULIB_VTK_QVIEWPORT_H
+#define ULIB_VTK_QVIEWPORT_H
+
+#include <QWidget>
+#include <QVTKOpenGLNativeWidget.h>
+
+#include <vtkCornerAnnotation.h>
+#include <vtkOrientationMarkerWidget.h>
+#include <vtkRenderer.h>
+#include <vtkRenderWindow.h>
+#include <vtkSmartPointer.h>
+
+#include "uLibVtkInterface.h"
+
+class vtkProp;
+class vtk3DWidget;
+class vtkRenderWindowInteractor;
+class vtkCameraOrientationWidget;
+
+namespace uLib {
+namespace Vtk {
+
+/**
+ * QViewport is a self-contained Qt widget that embeds a VTK renderer
+ * directly into the Qt application (no separate VTK window).
+ * Puppets and actors are added to the embedded renderer.
+ */
+class QViewport : public QWidget {
+    Q_OBJECT
+public:
+    explicit QViewport(QWidget* parent = nullptr);
+    virtual ~QViewport();
+
+    // Render scene
+    void Render();
+    void Reset();
+    void ZoomAuto();
+
+    // Puppet / prop management
+    void AddPuppet(Puppet &prop);
+    void RemovePuppet(Puppet &prop);
+    void addProp(vtkProp *prop);
+    void RemoveProp(vtkProp *prop);
+
+    // Widget integration
+    void AddWidget(vtk3DWidget *widget);
+
+    // Direct access to VTK internals
+    vtkRenderer*                GetRenderer()    { return m_Renderer; }
+    vtkRenderWindow*            GetRenderWindow();
+    vtkRenderWindowInteractor*  GetInteractor();
+    vtkCornerAnnotation*        GetAnnotation()  { return m_Annotation; }
+    vtkCameraOrientationWidget* GetCameraWidget(){ return m_CameraWidget; }
+    QVTKOpenGLNativeWidget*     GetWidget()      { return m_VtkWidget; }
+
+private:
+    void SetupPipeline();
+
+    QVTKOpenGLNativeWidget*             m_VtkWidget;
+    vtkRenderer*                         m_Renderer;
+    vtkCornerAnnotation*                 m_Annotation;
+    vtkOrientationMarkerWidget*          m_Marker;
+    vtkCameraOrientationWidget*          m_CameraWidget;
+};
+
+} // namespace Vtk
+} // namespace uLib
+
+#endif // ULIB_VTK_QVIEWPORT_H