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

reorganization of sources, moving cmt pertaining structures into HEP folder

Browse Source
This commit is contained in:
AndreaRigoni
2026-03-07 08:58:31 +00:00
parent 49cf0aeedd
commit e8f8e96521
70 changed files with 1468 additions and 1627 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/Vtk/HEP/MuonTomography/CMakeLists.txt Normal file
View File

@@ -0,0 +1,17 @@
################################################################################
##### Vtk/HEP/MuonTomography - VTK wrappers for MuonTomography objects ########
################################################################################
set(HEP_MUONTOMOGRAPHY_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/vtkVoxRaytracerRepresentation.cpp
PARENT_SCOPE)
set(HEP_MUONTOMOGRAPHY_HEADERS
${CMAKE_CURRENT_SOURCE_DIR}/vtkVoxRaytracerRepresentation.h
PARENT_SCOPE)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

15
src/Vtk/HEP/MuonTomography/testing/CMakeLists.txt Normal file
View File

@@ -0,0 +1,15 @@
# TESTS
set(TESTS
vtkVoxRaytracerTest
)
set(LIBRARIES
${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math
${PACKAGE_LIBPREFIX}Detectors
${PACKAGE_LIBPREFIX}Vtk
${VTK_LIBRARIES}
Boost::unit_test_framework
)
uLib_add_tests(VtkMuonTomography)

132
src/Vtk/HEP/MuonTomography/testing/vtkVoxRaytracerTest.cpp Normal file
View File

@@ -0,0 +1,132 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 <vtkBoxWidget.h>
#include <vtkCommand.h>
#include <vtkSmartPointer.h>
#include <vtkCornerAnnotation.h>
#include <HEP/Detectors/MuonScatter.h>
#include <Math/VoxRaytracer.h>
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
#include "Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h"
#include "Vtk/Math/vtkStructuredGrid.h"
#include "Vtk/uLibVtkViewer.h"
#define BOOST_TEST_MODULE VtkVoxRaytracerTest
#include <boost/test/unit_test.hpp>
using namespace uLib;
class vtkWidgetCallback : public vtkCommand {
public:
static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
void SetTracer(Vtk::vtkVoxRaytracerRepresentation *parent) {
this->vtk_raytr = parent;
}
void SetMuon(uLib::MuonScatter *muon) { this->muon = muon; }
void SetAnnotation(vtkCornerAnnotation *annotation) {
this->annotation = annotation;
}
virtual void Execute(vtkObject *caller, unsigned long, void *) {
char str[40];
vtk_raytr->SetMuon(*muon);
if (annotation) {
sprintf(str, "total length = %f", vtk_raytr->GetRay().TotalLength());
annotation->SetText(1, str);
for (int i = 0; i < vtk_raytr->GetRay().Data().size(); ++i) {
std::cout << "L[" << i << "] = " << vtk_raytr->GetRay().Data().at(i).L
<< "\n";
}
std::cout << "\n";
}
}
private:
vtkWidgetCallback() : vtk_raytr(NULL), muon(NULL), annotation(NULL) {}
uLib::VoxRaytracer *raytracer;
Vtk::vtkVoxRaytracerRepresentation *vtk_raytr;
uLib::MuonScatter *muon;
vtkCornerAnnotation *annotation;
};
BOOST_AUTO_TEST_CASE(vtkVoxRaytracerRepresentationTest) {
// muon scatter //
MuonScatter muon;
muon.LineIn().origin << -6, 12, -6, 1;
muon.LineIn().direction << 1, -1, 1, 0;
muon.LineOut().origin << 6, -4, 6, 1;
muon.LineOut().direction << 1, -1, 1, 0;
Vtk::vtkMuonScatter 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);
// voxraytracer //
VoxRaytracer rt(grid);
HPoint3f pt;
rt.GetEntryPoint(muon.LineIn(), pt);
std::cout << pt.transpose() << "\n";
Vtk::vtkVoxRaytracerRepresentation v_rt(rt);
v_rt.SetMuon(muon);
v_rt.SetRayColor(Vector4f(1, 0, 0, 1));
if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
// renderer //
Vtk::Viewer viewer;
// widget //
vtkBoxWidget *widget = v_grid.GetWidget();
vtkWidgetCallback *cbk = vtkWidgetCallback::New();
cbk->SetTracer(&v_rt);
cbk->SetMuon(&muon);
cbk->SetAnnotation(viewer.GetAnnotation());
widget->AddObserver(vtkCommand::InteractionEvent, cbk);
widget->SetInteractor(viewer.GetInteractor());
widget->PlaceWidget();
widget->On();
viewer.AddPuppet(v_grid);
viewer.AddPuppet(v_rt);
viewer.AddPuppet(v_muon);
viewer.Start();
}
BOOST_CHECK(v_rt.GetRay().Count() > 0);
}

323
src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.cpp Normal file
View File

@@ -0,0 +1,323 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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.
//////////////////////////////////////////////////////////////////////////////*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h"
#include "Math/VoxRaytracer.h"
// #include "Vtk/HEP/Detectors/vtkMuonEvent.h"
#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
namespace uLib {
namespace Vtk {
////////////////////////////////////////////////////////////////////////////////
////// VOX RAYTRACER REPRESENTATION ///////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content)
: m_Content(&content), m_Assembly(vtkAssembly::New()),
m_Sphere1(vtkSphereSource::New()), m_Sphere2(vtkSphereSource::New()),
m_Line1(vtkLineSource::New()), m_Line2(vtkLineSource::New()),
m_Line3(vtkLineSource::New()), m_RayLine(vtkAppendPolyData::New()),
m_RayLineActor(vtkActor::New()),
m_RayRepresentation(vtkAppendPolyData::New()),
m_RayRepresentationActor(vtkActor::New()),
m_Transform(vtkTransform::New()) {
default_radius = content.GetImage()->GetSpacing()(0) / 4;
m_Sphere1->SetRadius(default_radius);
m_Sphere2->SetRadius(default_radius);
m_SelectedElement = m_RayLine;
InstallPipe();
}
vtkVoxRaytracerRepresentation::~vtkVoxRaytracerRepresentation() {
m_Assembly->Delete();
m_RayLine->Delete();
m_RayLineActor->Delete();
m_RayRepresentationActor->Delete();
m_Transform->Delete();
}
VoxRaytracer *vtkVoxRaytracerRepresentation::GetRaytracerAlgorithm() {
return m_Content;
}
vtkProp *vtkVoxRaytracerRepresentation::GetProp() { return m_Assembly; }
vtkPolyData *vtkVoxRaytracerRepresentation::GetPolyData() const {
std::cout << "get Raytracer polydata\n";
m_SelectedElement->Update();
return m_SelectedElement->GetOutput();
}
void vtkVoxRaytracerRepresentation::SetRepresentationElements(
vtkVoxRaytracerRepresentation::RepresentationElements el) {
switch (el) {
case Vtk::vtkVoxRaytracerRepresentation::RayElements:
m_SelectedElement = m_RayLine;
break;
case Vtk::vtkVoxRaytracerRepresentation::VoxelsElements:
m_SelectedElement = m_RayRepresentation;
break;
default:
m_SelectedElement = m_RayLine;
break;
}
}
void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
HPoint3f pt1, pt2, src;
src = muon.LineIn().origin;
m_Content->GetEntryPoint(muon.LineIn(), pt1);
m_Sphere1->SetCenter(pt1(0), pt1(1), pt1(2));
m_Line1->SetPoint1(src(0), src(1), src(2));
m_Line1->SetPoint2(pt1(0), pt1(1), pt1(2));
HLine3f line_out = muon.LineOut();
src = line_out.origin;
float *direction = line_out.direction.data();
for (int i = 0; i < 3; ++i)
direction[i] *= -1;
m_Content->GetEntryPoint(line_out, pt2);
m_Sphere2->SetCenter(pt2(0), pt2(1), pt2(2));
m_Line2->SetPoint1(src(0), src(1), src(2));
m_Line2->SetPoint2(pt2(0), pt2(1), pt2(2));
m_Line3->SetPoint1(pt1(0), pt1(1), pt1(2));
m_Line3->SetPoint2(pt2(0), pt2(1), pt2(2));
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->InsertNextPoint(pt1(0), pt1(1), pt1(2));
points->InsertNextPoint(pt2(0), pt2(1), pt2(2));
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
line->GetPointIds()->SetId(0, 0);
line->GetPointIds()->SetId(1, 1);
lines->InsertNextCell(line);
vtkSmartPointer<vtkPolyData> linesPolyData =
vtkSmartPointer<vtkPolyData>::New();
linesPolyData->SetPoints(points);
linesPolyData->SetLines(lines);
m_RayLine->RemoveAllInputs();
#if VTK_MAJOR_VERSION <= 5
m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
#else
m_RayLine->AddInputData(linesPolyData);
#endif
m_RayLine->AddInputConnection(m_Line1->GetOutputPort());
m_RayLine->AddInputConnection(m_Sphere1->GetOutputPort());
m_RayLine->AddInputConnection(m_Line2->GetOutputPort());
m_RayLine->AddInputConnection(m_Sphere2->GetOutputPort());
vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
Matrix4f mat = m_Content->GetImage()->GetWorldMatrix();
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
vmat->SetElement(i, j, mat(i, j));
m_Transform->SetMatrix(vmat);
this->SetRay(pt1, pt2);
}
void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca) {
HPoint3f pt1, pt2, src;
src = muon.LineIn().origin;
m_Content->GetEntryPoint(muon.LineIn(), pt1);
m_Sphere1->SetCenter(pt1(0), pt1(1), pt1(2));
m_Line1->SetPoint1(src(0), src(1), src(2));
m_Line1->SetPoint2(pt1(0), pt1(1), pt1(2));
HLine3f line_out = muon.LineOut();
src = line_out.origin;
float *direction = line_out.direction.data();
for (int i = 0; i < 3; ++i)
direction[i] *= -1;
m_Content->GetEntryPoint(line_out, pt2);
m_Sphere2->SetCenter(pt2(0), pt2(1), pt2(2));
m_Line2->SetPoint1(src(0), src(1), src(2));
m_Line2->SetPoint2(pt2(0), pt2(1), pt2(2));
m_Line3->SetPoint1(pt1(0), pt1(1), pt1(2));
m_Line3->SetPoint2(pt2(0), pt2(1), pt2(2));
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->InsertNextPoint(pt1(0), pt1(1), pt1(2));
points->InsertNextPoint(poca(0), poca(1), poca(2));
points->InsertNextPoint(pt2(0), pt2(1), pt2(2));
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
for (unsigned int i = 0; i < 2; i++) {
vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
line->GetPointIds()->SetId(0, i);
line->GetPointIds()->SetId(1, i + 1);
lines->InsertNextCell(line);
}
vtkSmartPointer<vtkPolyData> linesPolyData =
vtkSmartPointer<vtkPolyData>::New();
linesPolyData->SetPoints(points);
linesPolyData->SetLines(lines);
m_RayLine->RemoveAllInputs();
#if VTK_MAJOR_VERSION <= 5
m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
#else
m_RayLine->AddInputData(linesPolyData);
#endif
m_RayLine->AddInputConnection(m_Line1->GetOutputPort());
m_RayLine->AddInputConnection(m_Sphere1->GetOutputPort());
m_RayLine->AddInputConnection(m_Line2->GetOutputPort());
m_RayLine->AddInputConnection(m_Sphere2->GetOutputPort());
vtkSmartPointer<vtkSphereSource> poca_sphere =
vtkSmartPointer<vtkSphereSource>::New();
poca_sphere->SetRadius(default_radius);
poca_sphere->SetCenter(poca(0), poca(1), poca(2));
m_RayLine->AddInputConnection(poca_sphere->GetOutputPort());
vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
Matrix4f mat = m_Content->GetImage()->GetWorldMatrix();
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
vmat->SetElement(i, j, mat(i, j));
m_Transform->SetMatrix(vmat);
if (m_Content->GetImage()->IsInsideBounds(poca))
this->SetRay(pt1, poca, pt2);
else
this->SetRay(pt1, pt2);
}
void vtkVoxRaytracerRepresentation::SetMuon(vtkMuonScatter &muon) {
HPoint3f poca = muon.GetPocaPoint();
MuonScatter &mu = muon.GetContent();
this->SetMuon(mu, poca);
}
VoxRaytracer::RayData vtkVoxRaytracerRepresentation::GetRay() { return m_Ray; }
void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out) {
m_Ray = m_Content->TraceBetweenPoints(in, out);
this->SetRay(&m_Ray);
}
void vtkVoxRaytracerRepresentation::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) {
vtkAppendPolyData *appender = m_RayRepresentation;
appender->RemoveAllInputs();
for (size_t i = 0; i < ray->Count(); ++i) {
int id = ray->Data().at(i).vox_id;
Vector3i idv = m_Content->GetImage()->UnMap(id);
vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
cube->SetBounds(idv(0), idv(0) + 1, idv(1), idv(1) + 1, idv(2), idv(2) + 1);
#if VTK_MAJOR_VERSION <= 5
cube->Update();
appender->AddInput(cube->GetOutput());
#else
appender->AddInputData(cube->GetOutput());
#endif
}
}
void vtkVoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba) {
this->SetColor(m_RayRepresentationActor, rgba);
}
void vtkVoxRaytracerRepresentation::SetRayColor(Vector4f rgba) {
this->SetColor(m_RayLineActor, rgba);
}
void vtkVoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba) {
if (!actor)
return;
vtkProperty *pr = actor->GetProperty();
pr->SetDiffuseColor(rgba(0), rgba(1), rgba(2));
pr->SetOpacity(rgba(3));
pr->SetDiffuse(1);
}
void vtkVoxRaytracerRepresentation::InstallPipe() {
vtkSmartPointer<vtkAppendPolyData> append =
vtkSmartPointer<vtkAppendPolyData>::New();
append->AddInputConnection(m_Sphere1->GetOutputPort());
append->AddInputConnection(m_Sphere2->GetOutputPort());
append->AddInputConnection(m_Line1->GetOutputPort());
append->AddInputConnection(m_Line2->GetOutputPort());
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(append->GetOutputPort());
vtkSmartPointer<vtkActor> actor = vtkActor::New();
actor->SetMapper(mapper);
actor->GetProperty()->SetColor(0.6, 0.6, 1);
this->SetProp(actor);
mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(m_RayLine->GetOutputPort());
m_RayLineActor->SetMapper(mapper);
m_RayLineActor->GetProperty()->SetColor(1, 0, 0);
this->SetProp(m_RayLineActor);
vtkSmartPointer<vtkTransformPolyDataFilter> polyfilter =
vtkSmartPointer<vtkTransformPolyDataFilter>::New();
polyfilter->SetInputConnection(m_RayRepresentation->GetOutputPort());
polyfilter->SetTransform(m_Transform);
mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(polyfilter->GetOutputPort());
vtkActor *vra = m_RayRepresentationActor;
vra->SetMapper(mapper);
vra->GetProperty()->SetOpacity(0.2);
vra->GetProperty()->SetEdgeVisibility(true);
vra->GetProperty()->SetColor(0.5, 0.5, 0.5);
this->SetProp(vra);
}
} // namespace Vtk
} // namespace uLib

123
src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h Normal file
View File

@@ -0,0 +1,123 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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.
//////////////////////////////////////////////////////////////////////////////*/
#ifndef U_VTKVOXRAYTRACERREPRESENTATION_H
#define U_VTKVOXRAYTRACERREPRESENTATION_H
#include <vtkCellArray.h>
#include <vtkLine.h>
#include <vtkActor.h>
#include <vtkAppendPolyData.h>
#include <vtkAssembly.h>
#include <vtkBoundingBox.h>
#include <vtkCubeSource.h>
#include <vtkLineSource.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProp3DCollection.h>
#include <vtkProperty.h>
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include "Math/Dense.h"
#include "Vtk/uLibVtkInterface.h"
#include "HEP/Detectors/MuonScatter.h"
#include "Math/StructuredGrid.h"
#include "Math/VoxRaytracer.h"
class vtkActor;
namespace uLib {
namespace Vtk {
class vtkVoxRaytracerRepresentation : public Puppet {
typedef VoxRaytracer Content;
public:
vtkVoxRaytracerRepresentation(Content &content);
~vtkVoxRaytracerRepresentation();
uLib::VoxRaytracer *GetRaytracerAlgorithm();
vtkProp *GetProp();
vtkPolyData *GetPolyData() const;
enum RepresentationElements { RayElements, VoxelsElements };
void SetRepresentationElements(enum RepresentationElements el);
void SetMuon(MuonScatter &muon);
void SetMuon(MuonScatter &muon, HPoint3f poca);
void SetMuon(class vtkMuonEvent &muon);
void SetMuon(class vtkMuonScatter &muon);
VoxRaytracer::RayData GetRay();
void SetRay(HPoint3f in, HPoint3f out);
void SetRay(HPoint3f in, HPoint3f mid, HPoint3f out);
void SetRay(VoxRaytracer::RayData *ray);
void SetVoxelsColor(Vector4f rgba);
void SetRayColor(Vector4f rgba);
private:
void InstallPipe();
void SetColor(vtkActor *actor, Vector4f rgba);
VoxRaytracer *m_Content;
Scalarf default_radius;
vtkAssembly *m_Assembly;
vtkAppendPolyData *m_RayLine;
vtkActor *m_RayLineActor;
vtkActor *m_RayRepresentationActor;
vtkSmartPointer<vtkTransform> m_Transform;
VoxRaytracer::RayData m_Ray;
vtkSmartPointer<vtkSphereSource> m_Sphere1;
vtkSmartPointer<vtkSphereSource> m_Sphere2;
vtkSmartPointer<vtkLineSource> m_Line1;
vtkSmartPointer<vtkLineSource> m_Line2;
vtkSmartPointer<vtkLineSource> m_Line3;
vtkSmartPointer<vtkAppendPolyData> m_RayRepresentation;
vtkAppendPolyData *m_SelectedElement;
};
} // namespace Vtk
} // namespace uLib
#endif // VTKVOXRAYTRACERREPRESENTATION_H