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

vtkGeantEvent

Browse Source
This commit is contained in:
AndreaRigoni
2026-03-16 17:51:53 +00:00
parent c63a1ae047
commit d8ef413216
31 changed files with 509 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Vtk/CMakeLists.txt
View File

@@ -3,6 +3,7 @@ set(HEADERS uLibVtkInterface.h
vtkContainerBox.h
vtkHandlerWidget.h
vtkQViewport.h
vtkPolydata.h
)
set(SOURCES uLibVtkInterface.cxx
@@ -10,6 +11,7 @@ set(SOURCES uLibVtkInterface.cxx
vtkContainerBox.cpp
vtkHandlerWidget.cpp
vtkQViewport.cpp
vtkPolydata.cpp
)
## Pull in Math VTK wrappers (sets MATH_SOURCES / MATH_HEADERS)

1
src/Vtk/HEP/Detectors/vtkMuonEvent.h
View File

@@ -45,6 +45,7 @@
#include "HEP/Detectors/MuonEvent.h"
#include "Vtk/uLibVtkInterface.h"
#include "Vtk/vtkPolydata.h"
namespace uLib {
namespace Vtk {

1
src/Vtk/HEP/Detectors/vtkMuonScatter.h
View File

@@ -46,6 +46,7 @@
#include "HEP/Detectors/MuonScatter.h"
#include "Vtk/uLibVtkInterface.h"
#include "Vtk/vtkPolydata.h"
class vtkRenderWindowInteractor;

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

@@ -15,6 +15,7 @@
#include "HEP/Geant/EmitterPrimary.hh"
#include "Math/ContainerBox.h"
#include "Math/Dense.h"
#include "Math/Units.h"
#include "Vtk/uLibVtkViewer.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
#include "Vtk/vtkContainerBox.h"
@@ -38,24 +39,21 @@ using namespace uLib;
class RandomEmitter : public Geant::EmitterPrimary {
public:
virtual void GeneratePrimaries(G4Event* anEvent) override {
// Start from a random point in a square at z = 5m
// Note: unit in Geant4 is mm by default if not specified,
// but here we use the constants from G4SystemOfUnits.h
double x = (G4UniformRand() - 0.5) * 2000; // -1m to 1m
double y = (G4UniformRand() - 0.5) * 2000; // -1m to 1m
double z = 5000.0; // 5m above origin
// Start from a random point on the top face of the world box (z = 15m)
double x = 0_m;
double y = 0_m;
double z = 14.9_m; // Top face
fParticleGun->SetParticlePosition(G4ThreeVector(x, y, z));
// Aim at a random point within the cube (which is at origin, size 1m)
double tx = (G4UniformRand() - 0.5) * 1000;
double ty = (G4UniformRand() - 0.5) * 1000;
double tz = (G4UniformRand() - 0.5) * 1000;
// Aim at a random point on the bottom face (z = -15m)
double tx = 0_m;
double ty = 0_m;
double tz = -14.9_m; // Bottom face
G4ThreeVector dir(tx - x, ty - y, tz - z);
dir = dir.unit();
fParticleGun->SetParticleMomentumDirection(dir);
fParticleGun->SetParticleMomentumDirection(dir.unit());
fParticleGun->SetParticleEnergy(15_GeV);
fParticleGun->GeneratePrimaryVertex(anEvent);
}
};
@@ -91,16 +89,20 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
state->viewer->GetRenderer()->Render();
state->viewer->GetRenderWindow()->Render();
}
else {
std::cout << " No event collected." << std::endl;
}
}
}
int main(int argc, char** argv) {
// 1. Setup Geant4 Scene
ContainerBox world_box(Vector3f(30000, 30000, 30000));
Geant::Scene scene;
scene.ConstructWorldBox(&world_box, "G4_AIR");
scene.ConstructWorldBox(Vector3f(30_m, 30_m, 30_m), "G4_AIR");
ContainerBox iron_box(Vector3f(1000, 1000, 1000));
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();
@@ -114,8 +116,16 @@ int main(int argc, char** argv) {
Vtk::Viewer viewer;
viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
// Visualize world box
Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
// vtkWorld->ShowBoundingBox(true);
vtkWorld->ShowScaleMeasures(true);
viewer.AddPuppet(*vtkWorld);
// Visualize iron cube
Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkIron);
// 3. Event Handling

4
src/Vtk/HEP/Geant/vtkGeantEvent.cpp
View File

@@ -97,8 +97,8 @@ void vtkGeantEvent::InstallPipe() {
m_MuonPath->SetMapper(mapper);
// Set default look: Red line
m_MuonPath->GetProperty()->SetColor(1.0, 0.0, 0.0);
m_MuonPath->GetProperty()->SetLineWidth(2.0);
m_MuonPath->GetProperty()->SetColor(1.0, 1.0, 1.0);
m_MuonPath->GetProperty()->SetLineWidth(1.0);
m_MuonPath->GetProperty()->SetAmbient(1.0);
this->SetProp(m_MuonPath);

1
src/Vtk/HEP/Geant/vtkGeantEvent.h
View File

@@ -28,6 +28,7 @@
#include "HEP/Geant/GeantEvent.h"
#include "uLibVtkInterface.h"
#include "vtkPolydata.h"
#include <vtkActor.h>
namespace uLib {

1
src/Vtk/Math/vtkQuadMesh.h
View File

@@ -28,6 +28,7 @@
#include "Math/QuadMesh.h"
#include "Vtk/uLibVtkInterface.h"
#include "Vtk/vtkPolydata.h"
class vtkPolyData;
class vtkActor;

1
src/Vtk/Math/vtkTriangleMesh.h
View File

@@ -28,6 +28,7 @@
#include "Math/TriangleMesh.h"
#include "Vtk/uLibVtkInterface.h"
#include "Vtk/vtkPolydata.h"
class vtkPolyData;
class vtkActor;

224
src/Vtk/uLibVtkInterface.cxx
View File

@@ -37,6 +37,7 @@
#endif
#include <string>
#include <vtkVersion.h>
#include <vtkProp.h>
#include <vtkActor.h>
@@ -46,10 +47,13 @@
#include <vtkPropCollection.h>
#include <vtkRendererCollection.h>
#include <vtkPropAssembly.h>
#include <vtkOutlineSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkCubeAxesActor.h>
#include <vtkRenderer.h>
#include <vtkProperty.h>
#include <vtkCamera.h>
#include <vtkPolyData.h>
#include <vtkPolyDataWriter.h>
#include <vtkXMLPolyDataWriter.h>
#include "uLibVtkInterface.h"
@@ -64,46 +68,6 @@ namespace Vtk {
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// POLYDATA //
void Polydata::SaveToFile(const char *vtk_file)
{
vtkSmartPointer<vtkPolyDataWriter> writer =
vtkSmartPointer<vtkPolyDataWriter>::New();
writer->SetFileName(vtk_file);
vtkPolyData * data = GetPolyData();
if(data) {
# if VTK_MAJOR_VERSION <= 5
writer->SetInputConnection(data->GetProducerPort());
# else
writer->SetInputData(data);
# endif
writer->Update();
}
}
void Polydata::SaveToXMLFile(const char *vtp_file)
{
vtkSmartPointer<vtkXMLPolyDataWriter> writer =
vtkSmartPointer<vtkXMLPolyDataWriter>::New();
writer->SetFileName(vtp_file);
vtkPolyData * data = GetPolyData();
if(data) {
# if VTK_MAJOR_VERSION <= 5
writer->SetInputConnection(data->GetProducerPort());
# else
writer->SetInputData(data);
# endif
writer->Update();
}
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -115,19 +79,59 @@ class PuppetData {
public:
PuppetData() :
m_Renderers(vtkRendererCollection::New()),
m_Assembly(vtkPropAssembly::New())
{}
m_Assembly(vtkPropAssembly::New()),
m_OutlineSource(NULL),
m_OutlineActor(NULL),
m_CubeAxesActor(NULL),
m_ShowBoundingBox(false),
m_ShowScaleMeasures(false),
m_Representation(-1),
m_Opacity(-1.0)
{
m_Color[0] = m_Color[1] = m_Color[2] = -1.0;
}
~PuppetData() {
m_Renderers->RemoveAllItems();
m_Assembly->GetParts()->RemoveAllItems();
m_Renderers->Delete();
m_Assembly->Delete();
if (m_OutlineSource) m_OutlineSource->Delete();
if (m_OutlineActor) m_OutlineActor->Delete();
if (m_CubeAxesActor) m_CubeAxesActor->Delete();
}
// members //
vtkRendererCollection *m_Renderers;
vtkPropAssembly *m_Assembly;
vtkOutlineSource *m_OutlineSource;
vtkActor *m_OutlineActor;
vtkCubeAxesActor *m_CubeAxesActor;
bool m_ShowBoundingBox;
bool m_ShowScaleMeasures;
int m_Representation;
double m_Color[3];
double m_Opacity;
void ApplyAppearance(vtkProp *p) {
vtkActor *actor = vtkActor::SafeDownCast(p);
if (!actor) return;
if (m_Representation != -1) {
actor->GetProperty()->SetRepresentation(m_Representation);
}
if (m_Color[0] != -1.0) {
actor->GetProperty()->SetColor(m_Color);
}
if (m_Opacity != -1.0) {
actor->GetProperty()->SetOpacity(m_Opacity);
}
}
};
// -------------------------------------------------------------------------- //
@@ -155,7 +159,10 @@ vtkProp *Puppet::GetProp()
void Puppet::SetProp(vtkProp *prop)
{
if(prop) d->m_Assembly->AddPart(prop);
if(prop) {
d->m_Assembly->AddPart(prop);
d->ApplyAppearance(prop);
}
}
void Puppet::RemoveProp(vtkProp *prop)
@@ -182,6 +189,12 @@ void Puppet::ConnectRenderer(vtkRenderer *renderer)
for (int i=0; i<props->GetNumberOfItems(); ++i)
renderer->AddActor(props->GetNextProp());
}
if (d->m_ShowBoundingBox && d->m_OutlineActor) renderer->AddActor(d->m_OutlineActor);
if (d->m_ShowScaleMeasures && d->m_CubeAxesActor) {
d->m_CubeAxesActor->SetCamera(renderer->GetActiveCamera());
renderer->AddActor(d->m_CubeAxesActor);
}
}
}
@@ -197,6 +210,10 @@ void Puppet::DisconnectRenderer(vtkRenderer *renderer)
for (int i=0; i<props->GetNumberOfItems(); ++i)
renderer->RemoveViewProp(props->GetNextProp());
}
if (d->m_ShowBoundingBox && d->m_OutlineActor) renderer->RemoveActor(d->m_OutlineActor);
if (d->m_ShowScaleMeasures && d->m_CubeAxesActor) renderer->RemoveActor(d->m_CubeAxesActor);
this->GetRenderers()->RemoveItem(renderer);
}
}
@@ -225,6 +242,121 @@ void Puppet::PrintSelf(std::ostream &o) const
d->m_Renderers->PrintSelf(o,vtkIndent(1));
}
void Puppet::ShowBoundingBox(bool show)
{
if (d->m_ShowBoundingBox == show) return;
d->m_ShowBoundingBox = show;
if (show) {
if (!d->m_OutlineActor) {
d->m_OutlineSource = vtkOutlineSource::New();
d->m_OutlineActor = vtkActor::New();
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(d->m_OutlineSource->GetOutputPort());
d->m_OutlineActor->SetMapper(mapper);
d->m_OutlineActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
}
double* bounds = d->m_Assembly->GetBounds();
d->m_OutlineSource->SetBounds(bounds);
d->m_OutlineSource->Update();
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
renderer->AddActor(d->m_OutlineActor);
}
} else {
if (d->m_OutlineActor) {
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
renderer->RemoveActor(d->m_OutlineActor);
}
}
}
}
void Puppet::ShowScaleMeasures(bool show)
{
if (d->m_ShowScaleMeasures == show) return;
d->m_ShowScaleMeasures = show;
if (show) {
if (!d->m_CubeAxesActor) {
d->m_CubeAxesActor = vtkCubeAxesActor::New();
d->m_CubeAxesActor->SetFlyModeToOuterEdges();
d->m_CubeAxesActor->SetUseTextActor3D(1);
d->m_CubeAxesActor->GetProperty()->SetColor(1.0, 1.0, 1.0);
}
double* bounds = d->m_Assembly->GetBounds();
d->m_CubeAxesActor->SetBounds(bounds);
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
d->m_CubeAxesActor->SetCamera(renderer->GetActiveCamera());
renderer->AddActor(d->m_CubeAxesActor);
}
} else {
if (d->m_CubeAxesActor) {
d->m_Renderers->InitTraversal();
for (int i = 0; i < d->m_Renderers->GetNumberOfItems(); ++i) {
vtkRenderer *renderer = d->m_Renderers->GetNextItem();
renderer->RemoveActor(d->m_CubeAxesActor);
}
}
}
}
void Puppet::SetRepresentation(Representation mode)
{
int rep = VTK_SURFACE;
switch (mode) {
case Points: rep = VTK_POINTS; break;
case Wireframe: rep = VTK_WIREFRAME; break;
case Surface: rep = VTK_SURFACE; break;
}
d->m_Representation = rep;
vtkPropCollection *props = d->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
d->ApplyAppearance(props->GetNextProp());
}
}
void Puppet::SetRepresentation(const char *mode)
{
std::string s(mode);
if (s == "points") SetRepresentation(Points);
else if (s == "wireframe") SetRepresentation(Wireframe);
else if (s == "shaded" || s == "surface") SetRepresentation(Surface);
}
void Puppet::SetColor(double r, double g, double b)
{
d->m_Color[0] = r;
d->m_Color[1] = g;
d->m_Color[2] = b;
vtkPropCollection *props = d->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
d->ApplyAppearance(props->GetNextProp());
}
}
void Puppet::SetOpacity(double alpha)
{
d->m_Opacity = alpha;
vtkPropCollection *props = d->m_Assembly->GetParts();
props->InitTraversal();
for (int i = 0; i < props->GetNumberOfItems(); ++i) {
d->ApplyAppearance(props->GetNextProp());
}
}

33
src/Vtk/uLibVtkInterface.h
View File

@@ -37,6 +37,7 @@ class vtkRenderer;
class vtkRendererCollection;
class vtkRenderWindowInteractor;
namespace uLib {
namespace Vtk {
@@ -59,8 +60,28 @@ public:
vtkRendererCollection *GetRenderers() const;
enum Representation {
Points,
Wireframe,
Surface
};
virtual void PrintSelf(std::ostream &o) const;
void ShowBoundingBox(bool show = true);
void ShowScaleMeasures(bool show = true);
void SetRepresentation(Representation mode);
void SetRepresentation(const char *mode);
void SetColor(double r, double g, double b);
void SetOpacity(double alpha);
virtual void ConnectInteractor(class vtkRenderWindowInteractor *interactor) {
(void)interactor;
}
@@ -75,18 +96,6 @@ private:
class PuppetData *d;
};
class Polydata {
public:
virtual vtkPolyData *GetPolyData() const { return NULL; }
virtual void SaveToFile(const char *vtk_file);
virtual void SaveToXMLFile(const char *vtp_file);
protected:
virtual ~Polydata() {}
};
} // namespace Vtk
} // namespace uLib

2
src/Vtk/uLibVtkViewer.cpp
View File

@@ -56,6 +56,8 @@ public:
};
vtkStandardNewMacro(vtkInteractorStyleNoSpin);
namespace uLib {
namespace Vtk {

1
src/Vtk/vtkContainerBox.h
View File

@@ -28,6 +28,7 @@
#include "Math/ContainerBox.h"
#include "uLibVtkInterface.h"
#include "vtkPolydata.h"
#include <vtkActor.h>
namespace uLib {

70
src/Vtk/vtkPolydata.cpp Normal file
View File

@@ -0,0 +1,70 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 <vtkVersion.h>
#include <vtkPolyData.h>
#include <vtkPolyDataWriter.h>
#include <vtkXMLPolyDataWriter.h>
#include <vtkSmartPointer.h>
#include "vtkPolydata.h"
namespace uLib {
namespace Vtk {
void Polydata::SaveToFile(const char *vtk_file)
{
vtkSmartPointer<vtkPolyDataWriter> writer =
vtkSmartPointer<vtkPolyDataWriter>::New();
writer->SetFileName(vtk_file);
vtkPolyData * data = GetPolyData();
if(data) {
# if VTK_MAJOR_VERSION <= 5
writer->SetInputConnection(data->GetProducerPort());
# else
writer->SetInputData(data);
# endif
writer->Update();
}
}
void Polydata::SaveToXMLFile(const char *vtp_file)
{
vtkSmartPointer<vtkXMLPolyDataWriter> writer =
vtkSmartPointer<vtkXMLPolyDataWriter>::New();
writer->SetFileName(vtp_file);
vtkPolyData * data = GetPolyData();
if(data) {
# if VTK_MAJOR_VERSION <= 5
writer->SetInputConnection(data->GetProducerPort());
# else
writer->SetInputData(data);
# endif
writer->Update();
}
}
} // Vtk
} // uLib

17
src/Vtk/vtkPolydata.h
View File

@@ -28,22 +28,25 @@
#ifndef VTKPOLYDATA_H
#define VTKPOLYDATA_H
#include "uLibVtkInterface.h"
class vtkPolyData;
namespace uLib {
namespace Vtk {
class vtkPolyData : public Abstract::uLibVtkPolydata {
typedef ::vtkPolyData Content;
class Polydata {
public:
virtual vtkPolyData *GetPolyData() const { return NULL; }
virtual void SaveToFile(const char *vtk_file);
virtual void SaveToXMLFile(const char *vtp_file);
protected:
virtual ~Polydata() {}
};
}
} // namespace Vtk
} // namespace uLib
#endif // VTKPOLYDATA_H