357 lines
12 KiB
C++
357 lines
12 KiB
C++
/*//////////////////////////////////////////////////////////////////////////////
|
|
// 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 ///////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
VoxRaytracerRepresentation::VoxRaytracerRepresentation(Content &content)
|
|
: m_Content(&content),
|
|
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()),
|
|
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);
|
|
m_Sphere2->SetRadius(default_radius);
|
|
m_SelectedElement = m_RayLine;
|
|
|
|
this->SetSelectable(false);
|
|
InstallPipe();
|
|
|
|
if (m_Content && m_Content->GetImage()) {
|
|
Object::connect(m_Content->GetImage(), &StructuredGrid::Updated, this, &VoxRaytracerRepresentation::imageUpdate);
|
|
}
|
|
}
|
|
|
|
VoxRaytracerRepresentation::~VoxRaytracerRepresentation() {
|
|
m_RayLine->Delete();
|
|
m_RayLineActor->Delete();
|
|
m_RayRepresentationActor->Delete();
|
|
m_Transform->Delete();
|
|
if (m_Muon) delete m_Muon;
|
|
}
|
|
|
|
uLib::VoxRaytracer *VoxRaytracerRepresentation::GetRaytracerAlgorithm() {
|
|
return m_Content;
|
|
}
|
|
|
|
void VoxRaytracerRepresentation::Update() {
|
|
this->imageUpdate();
|
|
}
|
|
|
|
void VoxRaytracerRepresentation::imageUpdate() {
|
|
if (m_HasMuon && m_Muon) {
|
|
if (m_HasPoca) {
|
|
this->SetMuon(m_Muon->GetModel(), m_Poca);
|
|
} else {
|
|
this->SetMuon(*m_Muon);
|
|
}
|
|
}
|
|
}
|
|
|
|
vtkPolyData *VoxRaytracerRepresentation::GetPolyData() const {
|
|
std::cout << "get Raytracer polydata\n";
|
|
m_SelectedElement->Update();
|
|
return m_SelectedElement->GetOutput();
|
|
}
|
|
|
|
void VoxRaytracerRepresentation::SetRepresentationElements(
|
|
VoxRaytracerRepresentation::RepresentationElements el) {
|
|
switch (el) {
|
|
case Vtk::VoxRaytracerRepresentation::RayElements:
|
|
m_SelectedElement = m_RayLine;
|
|
break;
|
|
case Vtk::VoxRaytracerRepresentation::VoxelsElements:
|
|
m_SelectedElement = m_RayRepresentation;
|
|
break;
|
|
default:
|
|
m_SelectedElement = m_RayLine;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void VoxRaytracerRepresentation::SetMuon(uLib::MuonScatter &muon) {
|
|
if (m_Muon) delete m_Muon;
|
|
m_Muon = new MuonScatter(muon);
|
|
m_HasMuon = true;
|
|
m_HasPoca = false;
|
|
|
|
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 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;
|
|
|
|
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 VoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
|
|
HPoint3f poca = muon.GetPocaPoint();
|
|
uLib::MuonScatter &mu = muon.GetModel();
|
|
this->SetMuon(mu, poca);
|
|
}
|
|
|
|
VoxRaytracer::RayData VoxRaytracerRepresentation::GetRay() { return m_Ray; }
|
|
|
|
void VoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out) {
|
|
m_Ray = m_Content->TraceBetweenPoints(in, out);
|
|
this->SetRay(&m_Ray);
|
|
}
|
|
|
|
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 VoxRaytracerRepresentation::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);
|
|
cube->Update();
|
|
#if VTK_MAJOR_VERSION <= 5
|
|
appender->AddInput(cube->GetOutput());
|
|
#else
|
|
appender->AddInputData(cube->GetOutput());
|
|
#endif
|
|
}
|
|
appender->Modified();
|
|
}
|
|
|
|
void VoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba) {
|
|
this->SetColor(m_RayRepresentationActor, rgba);
|
|
}
|
|
|
|
void VoxRaytracerRepresentation::SetRayColor(Vector4f rgba) {
|
|
this->SetColor(m_RayLineActor, rgba);
|
|
}
|
|
|
|
void VoxRaytracerRepresentation::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 VoxRaytracerRepresentation::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);
|
|
m_Asm->AddPart(actor);
|
|
|
|
mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
|
|
mapper->SetInputConnection(m_RayLine->GetOutputPort());
|
|
|
|
m_RayLineActor->SetMapper(mapper);
|
|
m_RayLineActor->GetProperty()->SetColor(1, 0, 0);
|
|
m_Asm->AddPart(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);
|
|
|
|
m_Asm->AddPart(vra);
|
|
|
|
this->SetProp(m_Asm);
|
|
}
|
|
|
|
} // namespace Vtk
|
|
} // namespace uLib
|