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

refactor: rename Vtk classes by removing the vtk prefix to follow project naming conventions

Browse Source
This commit is contained in:
AndreaRigoni
2026-04-08 15:14:55 +00:00
parent 8a01ee7f40
commit 77f00a2b8a
66 changed files with 494 additions and 477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -24,7 +24,7 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "HEP/Detectors/DetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "Math/Units.h"
#include "Vtk/uLibVtkViewer.h"
@@ -43,13 +43,13 @@ BOOST_AUTO_TEST_CASE(vtkDetectorChamberTest) {
d2.Scale(Vector3f(1_m, 2_m, 20_cm));
d2.Translate(Vector3f(1_m, 0, 10_m));
Vtk::vtkDetectorChamber v_d1(&d1);
Vtk::vtkDetectorChamber v_d2(&d2);
Vtk::DetectorChamber v_d1(&d1);
Vtk::DetectorChamber v_d2(&d2);
v_d1.SetRepresentation(Vtk::Puppet::Surface);
v_d2.SetRepresentation(Vtk::Puppet::Surface);
if (!v_d1.GetProp()) {
BOOST_FAIL("vtkDetectorChamber::GetProp() returned NULL");
BOOST_FAIL("DetectorChamber::GetProp() returned NULL");
}
if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {

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

@@ -23,8 +23,8 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "HEP/Detectors/DetectorChamber.h"
#include "HEP/Detectors/MuonScatter.h"
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
#include "Math/Units.h"
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
@@ -125,9 +125,9 @@ BOOST_AUTO_TEST_CASE(vtkDetectorMuonProjectionTest) {
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);
Vtk::DetectorChamber v_d1(&d1);
Vtk::DetectorChamber v_d2(&d2);
Vtk::MuonScatter v_event(event);
v_event.AddPocaPoint(HPoint3f(0, 0, 0));
v_event.SetColor(1, 0, 0); // Red muon event

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

@@ -24,7 +24,7 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
#include "HEP/Detectors/MuonScatter.h"
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
#include "Vtk/uLibVtkViewer.h"
@@ -41,7 +41,7 @@ BOOST_AUTO_TEST_CASE(vtkMuonScatterTest) {
event.LineOut().direction << 0, -1, 0, 0;
event.LineOut().origin << 0, -1, 0, 1;
Vtk::vtkMuonScatter v_event(event);
Vtk::MuonScatter v_event(event);
v_event.AddPocaPoint(HPoint3f(0, 0, 0));
v_event.SaveToXMLFile("vtk_testing_muonevent.vtp");
@@ -49,7 +49,7 @@ BOOST_AUTO_TEST_CASE(vtkMuonScatterTest) {
if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
Vtk::Viewer viewer;
// Vtk::Tie<Vtk::vtkMuonScatter> tms;
// Vtk::Tie<Vtk::MuonScatter> tms;
// tms.DoAction();
// Vtk::Tie<Vtk::Viewer> vms;
// vms.DoAction();

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

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

16
src/Vtk/HEP/Detectors/vtkDetectorChamber.h
View File

@@ -32,7 +32,7 @@
#include <vtkTransform.h>
#include "HEP/Detectors/DetectorChamber.h"
#include "Math/Dense.h"
#include "Vtk/Math/vtkDense.h"
#include "Vtk/uLibVtkInterface.h"
#include "Vtk/Math/vtkContainerBox.h"
#include <vtkActor.h>
@@ -44,17 +44,17 @@ class vtkPlaneSource;
namespace uLib {
namespace Vtk {
// class vtkHandlerWidget; // Removed as we use vtkBoxWidget now
// class HandlerWidget; // Removed as we use vtkBoxWidget now
class vtkDetectorChamber : public vtkContainerBox {
typedef DetectorChamber Content;
typedef vtkContainerBox BaseClass;
class DetectorChamber : public ContainerBox {
typedef uLib::DetectorChamber Content;
typedef ContainerBox BaseClass;
public:
vtkDetectorChamber(DetectorChamber *content);
virtual ~vtkDetectorChamber();
DetectorChamber(uLib::DetectorChamber *content);
virtual ~DetectorChamber();
Content *GetContent();
Content *GetContent() const override;
virtual void Update() override;

25
src/Vtk/HEP/Detectors/vtkMuonEvent.cxx
View File

@@ -27,7 +27,7 @@
#include "config.h"
#endif
#include "Math/Dense.h"
#include "Vtk/Math/vtkDense.h"
#include "Vtk/HEP/Detectors/vtkMuonEvent.h"
namespace uLib {
@@ -38,7 +38,7 @@ namespace Vtk {
class vtkWidgetCallback : public vtkCommand {
public:
static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
void SetParent(uLib::Vtk::vtkMuonEvent *parent) { this->parent = parent; }
void SetParent(uLib::Vtk::MuonEvent *parent) { this->parent = parent; }
virtual void Execute(vtkObject *caller, unsigned long, void *) {
vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget *>(caller);
@@ -48,30 +48,30 @@ public:
}
private:
uLib::Vtk::vtkMuonEvent *parent;
uLib::Vtk::MuonEvent *parent;
};
////////////////////////////////////////////////////////////////////////////////
///// VTK MUON EVENT /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
vtkMuonEvent::vtkMuonEvent(MuonEventData &content)
MuonEvent::MuonEvent(MuonEventData &content)
: m_PolyData(NULL), m_Appender(vtkAppendPolyData::New()),
content(&content) {
InstallPipe();
}
vtkMuonEvent::vtkMuonEvent(const MuonEventData &content)
MuonEvent::MuonEvent(const MuonEventData &content)
: m_PolyData(NULL), m_Appender(vtkAppendPolyData::New()),
content(const_cast<MuonEventData *>(&content)) {
InstallPipe();
}
vtkMuonEvent::~vtkMuonEvent() {}
MuonEvent::~MuonEvent() {}
vtkMuonEvent::Content &vtkMuonEvent::GetContent() { return *content; }
MuonEventData &MuonEvent::GetModel() { return *content; }
void vtkMuonEvent::PrintSelf(std::ostream &o) const {
void MuonEvent::PrintSelf(std::ostream &o) const {
o << "..:: MuonEvent ::..\n"
"\t[in] Origin > "
<< content->LineIn().origin.transpose() << "\n"
@@ -83,7 +83,7 @@ void vtkMuonEvent::PrintSelf(std::ostream &o) const {
<< "...................\n";
}
void vtkMuonEvent::InstallPipe() {
void MuonEvent::InstallPipe() {
vtkAppendPolyData *appender = m_Appender;
vtkSmartPointer<vtkPolyDataMapper> mapper =
@@ -121,11 +121,11 @@ void vtkMuonEvent::InstallPipe() {
this->SetProp(actor);
}
vtkPolyData *vtkMuonEvent::GetPolyData() const {
vtkPolyData *MuonEvent::GetPolyData() const {
return m_Appender->GetOutput();
}
void vtkMuonEvent::AddPocaPoint(HPoint3f poca) {
void MuonEvent::AddPocaPoint(HPoint3f poca) {
m_Poca = poca;
vtkSmartPointer<vtkSphereSource> sphere =
vtkSmartPointer<vtkSphereSource>::New();
@@ -139,7 +139,8 @@ void vtkMuonEvent::AddPocaPoint(HPoint3f poca) {
m_Appender->Update();
}
HPoint3f vtkMuonEvent::GetPocaPoint() { return m_Poca; }
HPoint3f MuonEvent::GetPocaPoint() { return m_Poca; }
uLib::Object* MuonEvent::GetContent() const { return (uLib::Object*)content; }
} // namespace Vtk
} // namespace uLib

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

@@ -41,7 +41,7 @@
#include <vtkCommand.h>
#include <vtkTransform.h>
#include "Math/Dense.h"
#include "Vtk/Math/vtkDense.h"
#include "HEP/Detectors/MuonEvent.h"
#include "Vtk/uLibVtkInterface.h"
@@ -50,15 +50,16 @@
namespace uLib {
namespace Vtk {
class vtkMuonEvent : public Puppet, public Polydata {
class MuonEvent : public Puppet, public Polydata {
typedef MuonEventData Content;
public:
vtkMuonEvent(const MuonEventData &content);
vtkMuonEvent(MuonEventData &content);
~vtkMuonEvent();
MuonEvent(const MuonEventData &content);
MuonEvent(MuonEventData &content);
~MuonEvent();
Content &GetContent();
Content &GetModel();
uLib::Object* GetContent() const override;
void PrintSelf(std::ostream &o) const;
@@ -73,7 +74,7 @@ public:
private:
void InstallPipe();
vtkMuonEvent::Content *content;
MuonEvent::Content *content;
vtkPolyData *m_PolyData;
vtkAppendPolyData *m_Appender;

24
src/Vtk/HEP/Detectors/vtkMuonScatter.cxx
View File

@@ -27,7 +27,7 @@
#include "config.h"
#endif
#include "Math/Dense.h"
#include "Vtk/Math/vtkDense.h"
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
namespace uLib {
@@ -37,21 +37,21 @@ namespace Vtk {
///// VTK MUON Scatter ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
vtkMuonScatter::vtkMuonScatter(MuonScatter &content)
MuonScatter::MuonScatter(uLib::MuonScatter &content)
: m_Content(&content), m_LineIn(vtkLineSource::New()),
m_LineOut(vtkLineSource::New()), m_PolyData(vtkPolyData::New()),
m_SpherePoca(NULL), m_Asm(vtkAssembly::New()) {
InstallPipe();
}
vtkMuonScatter::vtkMuonScatter(const MuonScatter &content)
: m_Content(const_cast<MuonScatter *>(&content)),
MuonScatter::MuonScatter(const MuonScatter &content)
: m_Content(content.m_Content),
m_LineIn(vtkLineSource::New()), m_LineOut(vtkLineSource::New()),
m_PolyData(vtkPolyData::New()), m_SpherePoca(NULL), m_Asm(vtkAssembly::New()) {
InstallPipe();
}
vtkMuonScatter::~vtkMuonScatter() {
MuonScatter::~MuonScatter() {
m_LineIn->Delete();
m_LineOut->Delete();
m_Asm->Delete();
@@ -59,11 +59,11 @@ vtkMuonScatter::~vtkMuonScatter() {
m_SpherePoca->Delete();
}
vtkMuonScatter::Content &vtkMuonScatter::GetContent() { return *m_Content; }
MuonScatter::Content &MuonScatter::GetModel() { return *m_Content; }
void vtkMuonScatter::PrintSelf(std::ostream &o) const {}
void MuonScatter::PrintSelf(std::ostream &o) const {}
void vtkMuonScatter::InstallPipe() {
void MuonScatter::InstallPipe() {
if (m_Content) {
vtkLineSource *line_in = m_LineIn;
vtkLineSource *line_out = m_LineOut;
@@ -99,7 +99,7 @@ void vtkMuonScatter::InstallPipe() {
this->SetProp(m_Asm);
}
vtkPolyData *vtkMuonScatter::GetPolyData() const {
vtkPolyData *MuonScatter::GetPolyData() const {
vtkSmartPointer<vtkAppendPolyData> append =
vtkSmartPointer<vtkAppendPolyData>::New();
append->AddInputConnection(m_LineIn->GetOutputPort());
@@ -111,7 +111,7 @@ vtkPolyData *vtkMuonScatter::GetPolyData() const {
return m_PolyData;
}
void vtkMuonScatter::AddPocaPoint(HPoint3f poca) {
void MuonScatter::AddPocaPoint(HPoint3f poca) {
vtkSphereSource *sphere = vtkSphereSource::New();
float size =
(m_Content->LineIn().origin - m_Content->LineOut().origin).head(3).norm();
@@ -129,7 +129,7 @@ void vtkMuonScatter::AddPocaPoint(HPoint3f poca) {
m_Asm->AddPart(actor);
}
HPoint3f vtkMuonScatter::GetPocaPoint() {
HPoint3f MuonScatter::GetPocaPoint() {
double center[3];
if (m_SpherePoca) {
m_SpherePoca->GetCenter(center);
@@ -139,7 +139,7 @@ HPoint3f vtkMuonScatter::GetPocaPoint() {
}
}
void vtkMuonScatter::ConnectInteractor(vtkRenderWindowInteractor *interactor) {
void MuonScatter::ConnectInteractor(vtkRenderWindowInteractor *interactor) {
// TODO
}

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

@@ -43,7 +43,7 @@
#include <vtkCommand.h>
#include <vtkTransform.h>
#include "Math/Dense.h"
#include "Vtk/Math/vtkDense.h"
#include "HEP/Detectors/MuonScatter.h"
#include "Vtk/uLibVtkInterface.h"
@@ -54,16 +54,17 @@ class vtkRenderWindowInteractor;
namespace uLib {
namespace Vtk {
class vtkMuonScatter : public Puppet, public Polydata {
typedef MuonScatter Content;
class MuonScatter : public Puppet, public Polydata {
typedef uLib::MuonScatter Content;
public:
vtkMuonScatter(const MuonScatter &content);
vtkMuonScatter(MuonScatter &content);
MuonScatter(const MuonScatter &content);
MuonScatter(uLib::MuonScatter &content);
~vtkMuonScatter();
~MuonScatter();
Content &GetContent();
Content &GetModel();
uLib::Object* GetContent() const override { return (uLib::Object*)m_Content; }
void PrintSelf(std::ostream &o) const;
@@ -81,7 +82,7 @@ protected:
private:
void InstallPipe();
vtkMuonScatter::Content *m_Content;
MuonScatter::Content *m_Content;
vtkLineSource *m_LineIn;
vtkLineSource *m_LineOut;
vtkSphereSource *m_SpherePoca;

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

@@ -10,11 +10,11 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Geant/Solid.h"
#include "HEP/Geant/GeantEvent.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
#include "HEP/Geant/Scene.h"
#include "HEP/Geant/EmitterPrimary.hh"
#include "Math/Cylinder.h"
#include "Math/Dense.h"
#include "Vtk/Math/vtkCylinder.h"
#include "Vtk/Math/vtkDense.h"
#include "Math/Units.h"
#include "Vtk/uLibVtkViewer.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
@@ -58,7 +58,7 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
std::cout << " Collected event " << lastEvent->GetEventID()
<< " with " << lastEvent->Path().size() << " steps." << std::endl;
Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
state->viewer->AddPuppet(*vtkEvent);
state->viewer->GetRenderer()->Render();
@@ -97,13 +97,13 @@ int main(int argc, char** argv) {
Vtk::Viewer viewer;
viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
vtkWorld->ShowScaleMeasures(true);
vtkWorld->SetRepresentation(Vtk::Puppet::Wireframe);
vtkWorld->SetSelectable(false);
viewer.AddPuppet(*vtkWorld);
Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkIron);

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

@@ -1,15 +1,15 @@
#include "Geant/Solid.h"
#include "HEP/Geant/GeantEvent.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
#include "HEP/Geant/Scene.h"
#include "HEP/Geant/EmitterPrimary.hh"
#include "Math/ContainerBox.h"
#include "Math/Dense.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "Vtk/Math/vtkDense.h"
#include "Math/Units.h"
#include "Vtk/uLibVtkViewer.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
#include "Vtk/HEP/Geant/vtkEmitterPrimary.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "HEP/Detectors/DetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include <vtkSmartPointer.h>
@@ -51,7 +51,7 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
<< " with " << lastEvent->Path().size() << " steps." << std::endl;
// Wrap it for VTK
Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
state->viewer->AddPuppet(*vtkEvent);
// Re-render
@@ -105,34 +105,34 @@ int main(int argc, char** argv) {
viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
// Visualize world box
Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
vtkWorld->ShowScaleMeasures(true);
vtkWorld->SetRepresentation(Vtk::Puppet::Wireframe);
vtkWorld->SetSelectable(false);
viewer.AddPuppet(*vtkWorld);
// Visualize iron cube
Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkIron);
// Visualize Top Chamber
Vtk::vtkDetectorChamber* vtkTop = new Vtk::vtkDetectorChamber(top_chamber_box);
Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box);
vtkTop->SetOpacity(0.5);
vtkTop->SetColor(0.2, 0.8, 0.2);
vtkTop->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkTop);
// Visualize Bottom Chamber
Vtk::vtkDetectorChamber* vtkBottom = new Vtk::vtkDetectorChamber(bottom_chamber_box);
Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box);
vtkBottom->SetOpacity(0.5);
vtkBottom->SetColor(0.2, 0.8, 0.2);
vtkBottom->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkBottom);
// Visualize Emitter
Vtk::vtkEmitterPrimary* vtkEmitter = new Vtk::vtkEmitterPrimary(*emitter);
Vtk::EmitterPrimary* vtkEmitter = new Vtk::EmitterPrimary(*emitter);
viewer.AddPuppet(*vtkEmitter);
// 3. Event Handling

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

@@ -10,11 +10,11 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Geant/Solid.h"
#include "HEP/Geant/GeantEvent.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
#include "HEP/Geant/Scene.h"
#include "HEP/Geant/EmitterPrimary.hh"
#include "Math/ContainerBox.h"
#include "Math/Dense.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "Vtk/Math/vtkDense.h"
#include "Math/Units.h"
#include "Vtk/uLibVtkViewer.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
@@ -82,7 +82,7 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
<< " with " << lastEvent->Path().size() << " steps." << std::endl;
// Wrap it for VTK
Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
state->viewer->AddPuppet(*vtkEvent);
// Re-render
@@ -117,13 +117,13 @@ int main(int argc, char** argv) {
viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
// Visualize world box
Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
// vtkWorld->ShowBoundingBox(true);
vtkWorld->ShowScaleMeasures(true);
viewer.AddPuppet(*vtkWorld);
// Visualize iron cube
Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkIron);

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

@@ -11,8 +11,8 @@
#include "Geant/Solid.h"
#include "HEP/Geant/Scene.h"
#include "Math/ContainerBox.h"
#include "Math/Dense.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "Vtk/Math/vtkDense.h"
#include "Math/Units.h"
#include "Vtk/uLibVtkViewer.h"
#include "Vtk/HEP/Geant/vtkGeantScene.h"
@@ -46,11 +46,11 @@ int main(int argc, char** argv) {
Vtk::Viewer viewer;
viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
Vtk::vtkGeantScene vtkScene(&scene);
Vtk::GeantScene vtkScene(&scene);
vtkScene.AddToViewer(viewer);
std::cout << "==================================================" << std::endl;
std::cout << " vtkGeantScene Test" << std::endl;
std::cout << " GeantScene Test" << std::endl;
std::cout << " World box + 1 iron cube displayed" << std::endl;
std::cout << "==================================================" << std::endl;

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

@@ -1,15 +1,15 @@
#include "Geant/Solid.h"
#include "HEP/Geant/GeantEvent.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
#include "HEP/Geant/Scene.h"
#include "HEP/Geant/EmitterPrimary.hh"
#include "Math/ContainerBox.h"
#include "Math/Dense.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "Vtk/Math/vtkDense.h"
#include "Math/Units.h"
#include "Vtk/uLibVtkViewer.h"
#include "Vtk/HEP/Geant/vtkGeantEvent.h"
#include "Vtk/HEP/Geant/vtkEmitterPrimary.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "HEP/Detectors/DetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include <vtkSmartPointer.h>
@@ -49,7 +49,7 @@ void KeyPressCallbackFunction(vtkObject* caller, long unsigned int eventId, void
std::cout << " Collected event " << lastEvent->GetEventID()
<< " with " << lastEvent->Path().size() << " steps." << std::endl;
Vtk::vtkGeantEvent* vtkEvent = new Vtk::vtkGeantEvent(lastEvent);
Vtk::GeantEvent* vtkEvent = new Vtk::GeantEvent(lastEvent);
state->viewer->AddPuppet(*vtkEvent);
state->viewer->GetRenderer()->Render();
@@ -107,32 +107,32 @@ int main(int argc, char** argv) {
Vtk::Viewer viewer;
viewer.GetRenderer()->SetBackground(0.05, 0.05, 0.1);
Vtk::vtkContainerBox* vtkWorld = new Vtk::vtkContainerBox(scene.GetWorldBox());
Vtk::ContainerBox* vtkWorld = new Vtk::ContainerBox(scene.GetWorldBox());
vtkWorld->ShowScaleMeasures(true);
vtkWorld->SetRepresentation(Vtk::Puppet::Wireframe);
vtkWorld->SetSelectable(false);
viewer.AddPuppet(*vtkWorld);
Vtk::vtkContainerBox* vtkIron = new Vtk::vtkContainerBox(&iron_box);
Vtk::ContainerBox* vtkIron = new Vtk::ContainerBox(&iron_box);
vtkIron->SetOpacity(0.2);
vtkIron->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkIron);
// Visualize Top Chamber
Vtk::vtkDetectorChamber* vtkTop = new Vtk::vtkDetectorChamber(top_chamber_box);
Vtk::DetectorChamber* vtkTop = new Vtk::DetectorChamber(top_chamber_box);
vtkTop->SetOpacity(0.5);
vtkTop->SetColor(0.2, 0.8, 0.2);
vtkTop->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkTop);
// Visualize Bottom Chamber
Vtk::vtkDetectorChamber* vtkBottom = new Vtk::vtkDetectorChamber(bottom_chamber_box);
Vtk::DetectorChamber* vtkBottom = new Vtk::DetectorChamber(bottom_chamber_box);
vtkBottom->SetOpacity(0.5);
vtkBottom->SetColor(0.2, 0.8, 0.2);
vtkBottom->SetRepresentation(Vtk::Puppet::Surface);
viewer.AddPuppet(*vtkBottom);
// Use vtkSkyPlaneEmitterPrimary instead of vtkEmitterPrimary
// Use vtkSkyPlaneEmitterPrimary instead of EmitterPrimary
Vtk::vtkSkyPlaneEmitterPrimary* vtkEmitter = new Vtk::vtkSkyPlaneEmitterPrimary(*emitter);
vtkEmitter->SetSelectable(false);
viewer.AddPuppet(*vtkEmitter);

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

@@ -13,8 +13,8 @@
#include "Vtk/HEP/Geant/vtkTessellatedSolid.h"
#include "Vtk/uLibVtkViewer.h"
#include "HEP/Geant/Solid.h"
#include "Math/ContainerBox.h"
#include "Math/TriangleMesh.h"
#include "Vtk/Math/vtkContainerBox.h"
#include "Vtk/Math/vtkTriangleMesh.h"
#include "Math/Units.h"
#include <vtkProperty.h>
@@ -31,7 +31,7 @@ int main(int argc, char** argv) {
Geant::BoxSolid gBox("MyBox", &box);
gBox.Update();
Vtk::vtkBoxSolid vtkBox(&gBox);
Vtk::BoxSolid vtkBox(&gBox);
// 2. Create a TessellatedSolid
Geant::TessellatedSolid gTess("MyTess");
@@ -53,7 +53,7 @@ int main(int argc, char** argv) {
gTess.SetMesh(mesh);
gTess.Update();
Vtk::vtkTessellatedSolid vtkTess(&gTess);
Vtk::TessellatedSolid vtkTess(&gTess);
// 3. Visualization setup
Vtk::Viewer viewer;

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

@@ -24,28 +24,28 @@
namespace uLib {
namespace Vtk {
vtkBoxSolid::vtkBoxSolid(Geant::BoxSolid *content)
: vtkGeantSolid(content), m_BoxContent(content) {
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, &vtkBoxSolid::Update);
m_UpdateConnection = Object::connect(m_BoxContent, &uLib::Object::Updated, this, &BoxSolid::Update);
// Initial sync
this->Update();
}
vtkBoxSolid::~vtkBoxSolid() {
BoxSolid::~BoxSolid() {
}
void vtkBoxSolid::Update() {
void BoxSolid::Update() {
ConnectionBlock blocker(m_UpdateConnection);
this->UpdateGeometry();
// Ensure base Puppet properties (color, opacity, etc) and transform are applied
this->Puppet::Update();
}
void vtkBoxSolid::SyncFromVtk() {
void BoxSolid::SyncFromVtk() {
this->Puppet::SyncFromVtk();
if (auto* proxy = vtkProp3D::SafeDownCast(this->GetProxyProp())) {
if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
@@ -54,17 +54,17 @@ void vtkBoxSolid::SyncFromVtk() {
}
}
void vtkBoxSolid::UpdateGeometry() {
// Sync geometry from G4VSolid provided by vtkGeantSolid (tessellation)
vtkGeantSolid::UpdateGeometry();
void BoxSolid::UpdateGeometry() {
// Sync geometry from G4VSolid provided by GeantSolid (tessellation)
GeantSolid::UpdateGeometry();
}
void vtkBoxSolid::UpdateTransform() {
void BoxSolid::UpdateTransform() {
// Take transform from Puppet base (which uses GetContent() -> ContainerBox TRS)
this->Puppet::Update();
}
void vtkBoxSolid::serialize_display(uLib::Archive::display_properties_archive &ar,
void BoxSolid::serialize_display(uLib::Archive::display_properties_archive &ar,
const unsigned int version) {
// Expose Geant solid properties and underlying Box/TRS properties
this->Puppet::serialize_display(ar, version);
@@ -76,8 +76,8 @@ void vtkBoxSolid::serialize_display(uLib::Archive::display_properties_archive &a
}
}
void vtkBoxSolid::InstallPipe() {
vtkGeantSolid::InstallPipe();
void BoxSolid::InstallPipe() {
GeantSolid::InstallPipe();
}
} // namespace Vtk

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

@@ -41,12 +41,12 @@ namespace Vtk {
/**
* @brief VTK Puppet for visualizing a Geant::BoxSolid.
*/
class vtkBoxSolid : public vtkGeantSolid {
uLibTypeMacro(vtkBoxSolid, uLib::Vtk::vtkGeantSolid)
class BoxSolid : public GeantSolid {
uLibTypeMacro(BoxSolid, uLib::Vtk::GeantSolid)
public:
vtkBoxSolid(Geant::BoxSolid *content);
virtual ~vtkBoxSolid();
BoxSolid(Geant::BoxSolid *content);
virtual ~BoxSolid();
virtual void Update() override;
virtual void UpdateGeometry() override;
@@ -71,7 +71,7 @@ protected:
Geant::BoxSolid *m_BoxContent;
uLib::Connection m_UpdateConnection;
ULIB_DECLARE_PROPERTIES(vtkBoxSolid)
ULIB_DECLARE_PROPERTIES(BoxSolid)
};
} // namespace Vtk

26
src/Vtk/HEP/Geant/vtkEmitterPrimary.cpp
View File

@@ -11,12 +11,12 @@
#include <vtkPolyData.h>
#include <vtkProperty.h>
#include <vtkCylinderSource.h>
#include "Math/vtkDense.h"
#include "Vtk/Math/vtkDense.h"
namespace uLib {
namespace Vtk {
vtkEmitterPrimary::vtkEmitterPrimary(Geant::EmitterPrimary &emitter)
EmitterPrimary::EmitterPrimary(Geant::EmitterPrimary &emitter)
: m_emitter(emitter), m_Actor(vtkActor::New()) {
vtkNew<vtkArrowSource> arrow;
@@ -43,16 +43,16 @@ vtkEmitterPrimary::vtkEmitterPrimary(Geant::EmitterPrimary &emitter)
this->SetProp(m_Actor);
Object::connect(&m_emitter, &Object::Updated, this, &vtkEmitterPrimary::contentUpdate);
Object::connect(&m_emitter, &Object::Updated, this, &EmitterPrimary::contentUpdate);
this->contentUpdate();
}
vtkEmitterPrimary::~vtkEmitterPrimary() {
Object::disconnect(&m_emitter, &Object::Updated, this, &vtkEmitterPrimary::contentUpdate);
EmitterPrimary::~EmitterPrimary() {
Object::disconnect(&m_emitter, &Object::Updated, this, &EmitterPrimary::contentUpdate);
m_Actor->Delete();
}
void vtkEmitterPrimary::contentUpdate() {
void EmitterPrimary::contentUpdate() {
vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
if (!vmat) {
vtkNew<vtkMatrix4x4> mat;
@@ -66,7 +66,7 @@ void vtkEmitterPrimary::contentUpdate() {
Puppet::Update();
}
void vtkEmitterPrimary::Update() {
void EmitterPrimary::Update() {
vtkMatrix4x4 *vmat = m_Actor->GetUserMatrix();
if (!vmat) return;
@@ -79,7 +79,7 @@ void vtkEmitterPrimary::Update() {
// vtkSkyPlaneEmitterPrimary
vtkSkyPlaneEmitterPrimary::vtkSkyPlaneEmitterPrimary(Geant::SkyPlaneEmitterPrimary &emitter)
: vtkEmitterPrimary(emitter), m_skyEmitter(emitter), m_PlaneSource(vtkPlaneSource::New()) {
: EmitterPrimary(emitter), m_skyEmitter(emitter), m_PlaneSource(vtkPlaneSource::New()) {
vtkNew<vtkAppendPolyData> append;
// Base class constructor already set an arrow. We keep it as a directional indicator.
@@ -107,27 +107,27 @@ void vtkSkyPlaneEmitterPrimary::contentUpdate() {
m_PlaneSource->SetPoint2(-size(0)/2.0, size(1)/2.0, 0.0);
m_PlaneSource->Update();
vtkEmitterPrimary::contentUpdate();
EmitterPrimary::contentUpdate();
}
// -------------------------------------------------------------------------- //
// vtkQuadMeshEmitterPrimary
vtkQuadMeshEmitterPrimary::vtkQuadMeshEmitterPrimary(Geant::QuadMeshEmitterPrimary &emitter)
: vtkEmitterPrimary(emitter), m_meshEmitter(emitter) {
: EmitterPrimary(emitter), m_meshEmitter(emitter) {
this->contentUpdate();
}
void vtkQuadMeshEmitterPrimary::contentUpdate() {
// For now stick with the arrow. In the future visualize the mesh if useful.
vtkEmitterPrimary::contentUpdate();
EmitterPrimary::contentUpdate();
}
// -------------------------------------------------------------------------- //
// vtkCylinderEmitterPrimary
vtkCylinderEmitterPrimary::vtkCylinderEmitterPrimary(Geant::CylinderEmitterPrimary &emitter)
: vtkEmitterPrimary(emitter), m_cylinderEmitter(emitter), m_CylinderSource(vtkCylinderSource::New()) {
: EmitterPrimary(emitter), m_cylinderEmitter(emitter), m_CylinderSource(vtkCylinderSource::New()) {
// vtkCylinderSource is along Y by default.
// We will update its actual dimensions in contentUpdate().
@@ -170,7 +170,7 @@ void vtkCylinderEmitterPrimary::contentUpdate() {
m_CylinderSource->SetCenter(0, h/2.0, 0);
m_CylinderSource->Update();
vtkEmitterPrimary::contentUpdate();
EmitterPrimary::contentUpdate();
}
} // namespace Vtk

12
src/Vtk/HEP/Geant/vtkEmitterPrimary.h
View File

@@ -14,10 +14,10 @@ class vtkCylinderSource;
namespace uLib {
namespace Vtk {
class vtkEmitterPrimary : public Puppet {
class EmitterPrimary : public Puppet {
public:
vtkEmitterPrimary(Geant::EmitterPrimary &emitter);
virtual ~vtkEmitterPrimary();
EmitterPrimary(Geant::EmitterPrimary &emitter);
virtual ~EmitterPrimary();
virtual void contentUpdate();
virtual void Update();
@@ -27,7 +27,7 @@ protected:
vtkActor *m_Actor;
};
class vtkSkyPlaneEmitterPrimary : public vtkEmitterPrimary {
class vtkSkyPlaneEmitterPrimary : public EmitterPrimary {
public:
vtkSkyPlaneEmitterPrimary(Geant::SkyPlaneEmitterPrimary &emitter);
virtual ~vtkSkyPlaneEmitterPrimary();
@@ -41,7 +41,7 @@ private:
class vtkQuadMeshEmitterPrimary : public vtkEmitterPrimary {
class vtkQuadMeshEmitterPrimary : public EmitterPrimary {
public:
vtkQuadMeshEmitterPrimary(Geant::QuadMeshEmitterPrimary &emitter);
virtual void contentUpdate();
@@ -50,7 +50,7 @@ private:
Geant::QuadMeshEmitterPrimary &m_meshEmitter;
};
class vtkCylinderEmitterPrimary : public vtkEmitterPrimary {
class vtkCylinderEmitterPrimary : public EmitterPrimary {
public:
vtkCylinderEmitterPrimary(Geant::CylinderEmitterPrimary &emitter);
virtual ~vtkCylinderEmitterPrimary();

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

@@ -35,23 +35,23 @@
namespace uLib {
namespace Vtk {
vtkGeantEvent::vtkGeantEvent(Content *content)
GeantEvent::GeantEvent(Content *content)
: m_MuonPath(vtkActor::New()), m_Content(content) {
this->InstallPipe();
this->Update();
}
vtkGeantEvent::~vtkGeantEvent() {
GeantEvent::~GeantEvent() {
m_MuonPath->Delete();
}
vtkPolyData *vtkGeantEvent::GetPolyData() const {
vtkPolyData *GeantEvent::GetPolyData() const {
if (!m_MuonPath || !m_MuonPath->GetMapper())
return NULL;
return vtkPolyData::SafeDownCast(m_MuonPath->GetMapper()->GetInput());
}
void vtkGeantEvent::Update() {
void GeantEvent::Update() {
if (!m_Content)
return;
@@ -88,7 +88,7 @@ void vtkGeantEvent::Update() {
}
}
void vtkGeantEvent::InstallPipe() {
void GeantEvent::InstallPipe() {
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();

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

@@ -34,12 +34,12 @@
namespace uLib {
namespace Vtk {
class vtkGeantEvent : public Puppet, public Polydata {
class GeantEvent : public Puppet, public Polydata {
typedef Geant::GeantEvent Content;
public:
vtkGeantEvent(Content *content);
~vtkGeantEvent();
GeantEvent(Content *content);
~GeantEvent();
virtual class vtkPolyData *GetPolyData() const override;

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

@@ -32,15 +32,15 @@
namespace uLib {
namespace Vtk {
vtkGeantScene::vtkGeantScene(Geant::Scene *scene)
GeantScene::GeantScene(Geant::Scene *scene)
: m_Scene(scene), m_WorldPuppet(nullptr) {
if (!m_Scene)
return;
// 1. Create the world box wireframe puppet
ContainerBox *worldBox = m_Scene->GetWorldBox();
uLib::ContainerBox *worldBox = m_Scene->GetWorldBox();
if (worldBox) {
m_WorldPuppet = new vtkContainerBox(worldBox);
m_WorldPuppet = new ContainerBox(worldBox);
m_WorldPuppet->SetRepresentation(Puppet::Wireframe);
m_WorldPuppet->ShowScaleMeasures(true);
}
@@ -56,13 +56,13 @@ vtkGeantScene::vtkGeantScene(Geant::Scene *scene)
// Only create a puppet if the solid has a valid G4VSolid
if (solid->GetG4Solid()) {
vtkGeantSolid *vtkSolid = nullptr;
GeantSolid *vtkSolid = nullptr;
if (auto *box = dynamic_cast<Geant::BoxSolid *>(solid)) {
vtkSolid = new vtkBoxSolid(box);
vtkSolid = new BoxSolid(box);
} else if (auto *tess = dynamic_cast<Geant::TessellatedSolid *>(solid)) {
vtkSolid = new vtkTessellatedSolid(tess);
vtkSolid = new TessellatedSolid(tess);
} else {
vtkSolid = new vtkGeantSolid(solid);
vtkSolid = new GeantSolid(solid);
vtkSolid->Update();
}
@@ -73,14 +73,14 @@ vtkGeantScene::vtkGeantScene(Geant::Scene *scene)
}
}
vtkGeantScene::~vtkGeantScene() {
GeantScene::~GeantScene() {
delete m_WorldPuppet;
for (auto *p : m_SolidPuppets) {
delete p;
}
}
void vtkGeantScene::AddToViewer(Viewport &viewer) {
void GeantScene::AddToViewer(Viewport &viewer) {
if (m_WorldPuppet) {
viewer.AddPuppet(*m_WorldPuppet);
}
@@ -89,7 +89,7 @@ void vtkGeantScene::AddToViewer(Viewport &viewer) {
}
}
void vtkGeantScene::RemoveFromViewer(Viewport &viewer) {
void GeantScene::RemoveFromViewer(Viewport &viewer) {
if (m_WorldPuppet) {
viewer.RemovePuppet(*m_WorldPuppet);
}

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

@@ -36,14 +36,14 @@
namespace uLib {
namespace Vtk {
class vtkGeantSolid;
class GeantSolid;
/**
* @brief VTK Puppet representing the entire Geant::Scene.
*
* When constructed, it creates child puppets for the world box (as a
* vtkContainerBox wireframe) and for each non-world Solid in the scene
* (as vtkGeantSolid surfaces).
* ContainerBox wireframe) and for each non-world Solid in the scene
* (as GeantSolid surfaces).
*
* Usage:
* @code
@@ -53,15 +53,15 @@ class vtkGeantSolid;
* scene.Initialize();
*
* Vtk::Viewer viewer;
* Vtk::vtkGeantScene vtkScene(&scene);
* Vtk::GeantScene vtkScene(&scene);
* vtkScene.AddToViewer(viewer);
* viewer.Start();
* @endcode
*/
class vtkGeantScene : public Object {
class GeantScene : public Object {
public:
vtkGeantScene(Geant::Scene *scene);
~vtkGeantScene();
GeantScene(Geant::Scene *scene);
~GeantScene();
/// Add all puppets (world box + solids) to a viewer.
void AddToViewer(class Viewport &viewer);
@@ -70,15 +70,15 @@ public:
void RemoveFromViewer(class Viewport &viewer);
/// Get the world box puppet
vtkContainerBox* GetWorldPuppet() const { return m_WorldPuppet; }
ContainerBox* GetWorldPuppet() const { return m_WorldPuppet; }
/// Get the solid puppets
const std::vector<vtkGeantSolid*>& GetSolidPuppets() const { return m_SolidPuppets; }
const std::vector<GeantSolid*>& GetSolidPuppets() const { return m_SolidPuppets; }
private:
Geant::Scene *m_Scene;
vtkContainerBox *m_WorldPuppet;
std::vector<vtkGeantSolid*> m_SolidPuppets;
ContainerBox *m_WorldPuppet;
std::vector<GeantSolid*> m_SolidPuppets;
};
} // namespace Vtk

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

@@ -42,27 +42,27 @@
namespace uLib {
namespace Vtk {
vtkGeantSolid::vtkGeantSolid(Content *content)
GeantSolid::GeantSolid(Content *content)
: m_SolidActor(vtkActor::New()), m_Content(content) {
this->InstallPipe();
}
vtkGeantSolid::~vtkGeantSolid() {
GeantSolid::~GeantSolid() {
m_SolidActor->Delete();
}
vtkPolyData *vtkGeantSolid::GetPolyData() const {
vtkPolyData *GeantSolid::GetPolyData() const {
if (!m_SolidActor || !m_SolidActor->GetMapper())
return NULL;
return vtkPolyData::SafeDownCast(m_SolidActor->GetMapper()->GetInput());
}
void vtkGeantSolid::Update() {
void GeantSolid::Update() {
this->UpdateGeometry();
this->UpdateTransform();
}
void vtkGeantSolid::UpdateGeometry() {
void GeantSolid::UpdateGeometry() {
if (!m_Content)
return;
@@ -110,7 +110,7 @@ void vtkGeantSolid::UpdateGeometry() {
}
}
void vtkGeantSolid::UpdateTransform() {
void GeantSolid::UpdateTransform() {
if (!m_Content || !m_SolidActor)
return;
@@ -142,7 +142,7 @@ void vtkGeantSolid::UpdateTransform() {
}
}
void vtkGeantSolid::InstallPipe() {
void GeantSolid::InstallPipe() {
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();

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

@@ -42,12 +42,12 @@ namespace Vtk {
* Works with BoxSolid, TessellatedSolid, or any Solid that provides
* a valid G4VSolid via GetG4Solid().
*/
class vtkGeantSolid : public Puppet, public Polydata {
class GeantSolid : public Puppet, public Polydata {
typedef Geant::Solid Content;
public:
vtkGeantSolid(Content *content);
~vtkGeantSolid();
GeantSolid(Content *content);
~GeantSolid();
virtual class vtkPolyData *GetPolyData() const override;

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

@@ -18,22 +18,22 @@
namespace uLib {
namespace Vtk {
vtkTessellatedSolid::vtkTessellatedSolid(Geant::TessellatedSolid *content)
: vtkGeantSolid(content), m_TessContent(content) {
TessellatedSolid::TessellatedSolid(Geant::TessellatedSolid *content)
: GeantSolid(content), m_TessContent(content) {
this->Update();
}
vtkTessellatedSolid::~vtkTessellatedSolid() {}
TessellatedSolid::~TessellatedSolid() {}
void vtkTessellatedSolid::Update() {
void TessellatedSolid::Update() {
this->UpdateGeometry();
this->UpdateTransform();
}
void vtkTessellatedSolid::UpdateGeometry() {
void TessellatedSolid::UpdateGeometry() {
if (!m_TessContent || m_TessContent->GetMesh().Points().empty()) {
// Fallback to base tessellation if no model mesh
vtkGeantSolid::UpdateGeometry();
GeantSolid::UpdateGeometry();
return;
}

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

@@ -20,10 +20,10 @@ namespace Vtk {
/**
* @brief VTK Puppet for visualizing a Geant::TessellatedSolid.
*/
class vtkTessellatedSolid : public vtkGeantSolid {
class TessellatedSolid : public GeantSolid {
public:
vtkTessellatedSolid(Geant::TessellatedSolid *content);
virtual ~vtkTessellatedSolid();
TessellatedSolid(Geant::TessellatedSolid *content);
virtual ~TessellatedSolid();
virtual void Update() override;
virtual void UpdateGeometry() override;

10
src/Vtk/HEP/MuonTomography/testing/vtkVoxRaytracerTest.cpp
View File

@@ -46,7 +46,7 @@ class vtkWidgetCallback : public vtkCommand {
public:
static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
void SetTracer(Vtk::vtkVoxRaytracerRepresentation *parent) {
void SetTracer(Vtk::VoxRaytracerRepresentation *parent) {
this->vtk_raytr = parent;
}
@@ -74,7 +74,7 @@ private:
vtkWidgetCallback() : vtk_raytr(NULL), muon(NULL), annotation(NULL) {}
uLib::VoxRaytracer *raytracer;
Vtk::vtkVoxRaytracerRepresentation *vtk_raytr;
Vtk::VoxRaytracerRepresentation *vtk_raytr;
uLib::MuonScatter *muon;
vtkCornerAnnotation *annotation;
};
@@ -87,14 +87,14 @@ BOOST_AUTO_TEST_CASE(vtkVoxRaytracerRepresentationTest) {
muon.LineOut().origin << 6, -4, 6, 1;
muon.LineOut().direction << 1, -1, 1, 0;
Vtk::vtkMuonScatter v_muon(muon);
Vtk::MuonScatter v_muon(muon);
// structured grid //
StructuredGrid grid(Vector3i(12, 10, 12));
grid.SetSpacing(Vector3f(1, 1, 1));
grid.SetPosition(Vector3f(0, 0, 0));
Vtk::vtkStructuredGrid v_grid(grid);
Vtk::StructuredGrid v_grid(grid);
// voxraytracer //
VoxRaytracer rt(grid);
@@ -102,7 +102,7 @@ BOOST_AUTO_TEST_CASE(vtkVoxRaytracerRepresentationTest) {
rt.GetEntryPoint(muon.LineIn(), pt);
std::cout << pt.transpose() << "\n";
Vtk::vtkVoxRaytracerRepresentation v_rt(rt);
Vtk::VoxRaytracerRepresentation v_rt(rt);
v_rt.SetMuon(muon);
v_rt.SetRayColor(Vector4f(1, 0, 0, 1));

10
src/Vtk/HEP/MuonTomography/vtkMuonContainerScattering.h
View File

@@ -30,7 +30,7 @@
#include "Math/Dense.h"
#include "Vtk/Math/vtkDense.h"
#include "uLibVtkInterface.h"
#include "Detectors/MuonScatter.h"
@@ -39,11 +39,11 @@ class vtkRenderWindowInteractor;
namespace uLib {
class vtkMuonContainerScattering : public Abstract::uLibVtkPolydata {
typedef MuonScatter Content;
class MuonContainerScattering : public Abstract::uLibVtkPolydata {
typedef uLib::MuonScatter Content;
public:
vtkMuonContainerScattering(const MuonScatter &content);
~vtkMuonScatter();
MuonContainerScattering(const MuonScatter &content);
~MuonScatter();
Content& GetContent();

60
src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.cpp
View File

@@ -41,7 +41,7 @@ namespace Vtk {
////// VOX RAYTRACER REPRESENTATION ///////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
VoxRaytracerRepresentation::VoxRaytracerRepresentation(Content &content)
: m_Content(&content),
m_Sphere1(vtkSphereSource::New()), m_Sphere2(vtkSphereSource::New()),
m_Line1(vtkLineSource::New()), m_Line2(vtkLineSource::New()),
@@ -51,6 +51,7 @@ vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
m_RayRepresentationActor(vtkActor::New()),
m_Transform(vtkTransform::New()),
m_Asm(vtkAssembly::New()),
m_Muon(nullptr),
m_HasMuon(false), m_HasPoca(false) {
default_radius = content.GetImage()->GetSpacing()(0) / 4;
m_Sphere1->SetRadius(default_radius);
@@ -61,48 +62,49 @@ vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
InstallPipe();
if (m_Content && m_Content->GetImage()) {
Object::connect(m_Content->GetImage(), &StructuredGrid::Updated, this, &vtkVoxRaytracerRepresentation::imageUpdate);
Object::connect(m_Content->GetImage(), &StructuredGrid::Updated, this, &VoxRaytracerRepresentation::imageUpdate);
}
}
vtkVoxRaytracerRepresentation::~vtkVoxRaytracerRepresentation() {
VoxRaytracerRepresentation::~VoxRaytracerRepresentation() {
m_RayLine->Delete();
m_RayLineActor->Delete();
m_RayRepresentationActor->Delete();
m_Transform->Delete();
if (m_Muon) delete m_Muon;
}
uLib::VoxRaytracer *vtkVoxRaytracerRepresentation::GetRaytracerAlgorithm() {
uLib::VoxRaytracer *VoxRaytracerRepresentation::GetRaytracerAlgorithm() {
return m_Content;
}
void vtkVoxRaytracerRepresentation::Update() {
void VoxRaytracerRepresentation::Update() {
this->imageUpdate();
}
void vtkVoxRaytracerRepresentation::imageUpdate() {
if (m_HasMuon) {
void VoxRaytracerRepresentation::imageUpdate() {
if (m_HasMuon && m_Muon) {
if (m_HasPoca) {
this->SetMuon(m_Muon, m_Poca);
this->SetMuon(m_Muon->GetModel(), m_Poca);
} else {
this->SetMuon(m_Muon);
this->SetMuon(*m_Muon);
}
}
}
vtkPolyData *vtkVoxRaytracerRepresentation::GetPolyData() const {
vtkPolyData *VoxRaytracerRepresentation::GetPolyData() const {
std::cout << "get Raytracer polydata\n";
m_SelectedElement->Update();
return m_SelectedElement->GetOutput();
}
void vtkVoxRaytracerRepresentation::SetRepresentationElements(
vtkVoxRaytracerRepresentation::RepresentationElements el) {
void VoxRaytracerRepresentation::SetRepresentationElements(
VoxRaytracerRepresentation::RepresentationElements el) {
switch (el) {
case Vtk::vtkVoxRaytracerRepresentation::RayElements:
case Vtk::VoxRaytracerRepresentation::RayElements:
m_SelectedElement = m_RayLine;
break;
case Vtk::vtkVoxRaytracerRepresentation::VoxelsElements:
case Vtk::VoxRaytracerRepresentation::VoxelsElements:
m_SelectedElement = m_RayRepresentation;
break;
default:
@@ -111,8 +113,9 @@ void vtkVoxRaytracerRepresentation::SetRepresentationElements(
}
}
void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
m_Muon = muon;
void VoxRaytracerRepresentation::SetMuon(uLib::MuonScatter &muon) {
if (m_Muon) delete m_Muon;
m_Muon = new MuonScatter(muon);
m_HasMuon = true;
m_HasPoca = false;
@@ -173,8 +176,9 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
this->SetRay(pt1, pt2);
}
void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca) {
m_Muon = muon;
void VoxRaytracerRepresentation::SetMuon(uLib::MuonScatter &muon, HPoint3f poca) {
if (m_Muon) delete m_Muon;
m_Muon = new MuonScatter(muon);
m_Poca = poca;
m_HasMuon = true;
m_HasPoca = true;
@@ -247,27 +251,27 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca) {
this->SetRay(pt1, pt2);
}
void vtkVoxRaytracerRepresentation::SetMuon(vtkMuonScatter &muon) {
void VoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
HPoint3f poca = muon.GetPocaPoint();
MuonScatter &mu = muon.GetContent();
uLib::MuonScatter &mu = muon.GetModel();
this->SetMuon(mu, poca);
}
VoxRaytracer::RayData vtkVoxRaytracerRepresentation::GetRay() { return m_Ray; }
VoxRaytracer::RayData VoxRaytracerRepresentation::GetRay() { return m_Ray; }
void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out) {
void VoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out) {
m_Ray = m_Content->TraceBetweenPoints(in, out);
this->SetRay(&m_Ray);
}
void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f mid,
void VoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f mid,
HPoint3f out) {
m_Ray = m_Content->TraceBetweenPoints(in, mid);
m_Ray.AppendRay(m_Content->TraceBetweenPoints(mid, out));
this->SetRay(&m_Ray);
}
void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray) {
void VoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray) {
vtkAppendPolyData *appender = m_RayRepresentation;
appender->RemoveAllInputs();
@@ -286,15 +290,15 @@ void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray) {
appender->Modified();
}
void vtkVoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba) {
void VoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba) {
this->SetColor(m_RayRepresentationActor, rgba);
}
void vtkVoxRaytracerRepresentation::SetRayColor(Vector4f rgba) {
void VoxRaytracerRepresentation::SetRayColor(Vector4f rgba) {
this->SetColor(m_RayLineActor, rgba);
}
void vtkVoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba) {
void VoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba) {
if (!actor)
return;
vtkProperty *pr = actor->GetProperty();
@@ -303,7 +307,7 @@ void vtkVoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba) {
pr->SetDiffuse(1);
}
void vtkVoxRaytracerRepresentation::InstallPipe() {
void VoxRaytracerRepresentation::InstallPipe() {
vtkSmartPointer<vtkAppendPolyData> append =
vtkSmartPointer<vtkAppendPolyData>::New();

22
src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h
View File

@@ -44,13 +44,13 @@
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include "Math/Dense.h"
#include "Vtk/Math/vtkDense.h"
#include "Vtk/uLibVtkInterface.h"
#include "HEP/Detectors/MuonScatter.h"
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
#include "Math/StructuredGrid.h"
#include "Vtk/Math/vtkStructuredGrid.h"
#include "Math/VoxRaytracer.h"
class vtkActor;
@@ -58,12 +58,12 @@ class vtkActor;
namespace uLib {
namespace Vtk {
class vtkVoxRaytracerRepresentation : public Puppet {
class VoxRaytracerRepresentation : public Puppet {
typedef VoxRaytracer Content;
public:
vtkVoxRaytracerRepresentation(Content &content);
~vtkVoxRaytracerRepresentation();
VoxRaytracerRepresentation(Content &content);
~VoxRaytracerRepresentation();
uLib::VoxRaytracer *GetRaytracerAlgorithm();
@@ -76,13 +76,13 @@ public:
enum RepresentationElements { RayElements, VoxelsElements };
void SetRepresentationElements(enum RepresentationElements el);
void SetMuon(MuonScatter &muon);
void SetMuon(uLib::MuonScatter &muon);
void SetMuon(MuonScatter &muon, HPoint3f poca);
void SetMuon(uLib::MuonScatter &muon, HPoint3f poca);
void SetMuon(class vtkMuonEvent &muon);
void SetMuon(class MuonEvent &muon);
void SetMuon(class vtkMuonScatter &muon);
void SetMuon(class MuonScatter &muon);
VoxRaytracer::RayData GetRay();
@@ -101,7 +101,7 @@ private:
void SetColor(vtkActor *actor, Vector4f rgba);
VoxRaytracer *m_Content;
MuonScatter m_Muon;
MuonScatter *m_Muon;
HPoint3f m_Poca;
bool m_HasMuon;
bool m_HasPoca;