add stl test

CMakeLists.txt

@@ -146,7 +146,8 @@ else()
                                 RenderingFreeType
                                 RenderingGL2PSOpenGL2
                                 RenderingOpenGL2
-                                RenderingVolumeOpenGL2)
+                                RenderingVolumeOpenGL2
+                                 IOGeometry)
 endif()
 
 set(CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_INCLUDES math.h)
@@ -204,8 +205,8 @@ add_subdirectory(${SRC_DIR}/Core)
 include_directories(${SRC_DIR}/Math)
 add_subdirectory(${SRC_DIR}/Math)
 
-include_directories(${SRC_DIR}/Detectors)
+include_directories(${SRC_DIR}/HEP)
-add_subdirectory(${SRC_DIR}/Detectors)
+add_subdirectory(${SRC_DIR}/HEP)
 
 include_directories(${SRC_DIR}/Root)
 add_subdirectory(${SRC_DIR}/Root)

src/Core/CMakeLists.txt

@@ -49,7 +49,7 @@ endif()
 target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
-        EXPORT "${PROJECT_NAME}Targets"
+        EXPORT "uLibTargets"
         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 

src/Detectors/CMakeLists.txt

@@ -1,12 +0,0 @@
-set(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
-
-set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
-
-
-install(FILES ${HEADERS}
-        DESTINATION ${INSTALL_INC_DIR}/Detectors)
-
-if(BUILD_TESTING)
-  include(uLibTargetMacros)
-  add_subdirectory(testing)
-endif()

src/HEP/CMakeLists.txt

@@ -0,0 +1,12 @@
+
+################################################################################
+##### HEP - High Energy Physics modules ########################################
+################################################################################
+
+include_directories(${SRC_DIR}/HEP)
+
+add_subdirectory(Detectors)
+add_subdirectory(Geant)
+
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} PARENT_SCOPE)

src/HEP/Detectors/CMakeLists.txt

@@ -0,0 +1,34 @@
+set(HEADERS
+    ChamberHitEvent.h
+    DetectorChamber.h
+    ExperimentFitEvent.h
+    HierarchicalEncoding.h
+    Hit.h
+    HitMC.h
+    LinearFit.h
+    MuonError.h
+    MuonEvent.h
+    MuonScatter.h
+)
+
+set(libname ${PACKAGE_LIBPREFIX}Detectors)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
+
+## Headers-only INTERFACE library
+add_library(${libname} INTERFACE)
+target_include_directories(${libname} INTERFACE
+    $<BUILD_INTERFACE:${SRC_DIR}>
+    $<INSTALL_INTERFACE:${INSTALL_INC_DIR}>
+)
+
+install(TARGETS ${libname}
+        EXPORT "uLibTargets")
+
+install(FILES ${HEADERS}
+        DESTINATION ${INSTALL_INC_DIR}/HEP/Detectors)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/HEP/Geant/CMakeLists.txt

@@ -0,0 +1,52 @@
+
+################################################################################
+##### HEP/Geant - Geant4 integration library ###################################
+################################################################################
+
+find_package(Geant4 QUIET)
+
+if(NOT Geant4_FOUND)
+    message(STATUS "Geant4 not found - skipping mutomGeant library")
+    return()
+endif()
+
+message(STATUS "Geant4 found: ${Geant4_VERSION}")
+include(${Geant4_USE_FILE})
+
+set(HEADERS
+    GeantEvent.h
+    Matter.h
+    Scene.h
+    Solid.h
+)
+
+set(SOURCES
+    Scene.cpp
+    Solid.cpp
+)
+
+set(libname ${PACKAGE_LIBPREFIX}Geant)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Geant PARENT_SCOPE)
+
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
+
+target_include_directories(${libname} PRIVATE ${Geant4_INCLUDE_DIRS})
+
+target_link_libraries(${libname}
+    ${PACKAGE_LIBPREFIX}Core
+    ${PACKAGE_LIBPREFIX}Math
+    ${PACKAGE_LIBPREFIX}Detectors
+    ${Geant4_LIBRARIES}
+)
+
+install(TARGETS ${libname}
+        EXPORT "uLibTargets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS}
+        DESTINATION ${INSTALL_INC_DIR}/HEP/Geant)

src/HEP/Geant/GeantEvent.h

@@ -23,8 +23,6 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_GEANTEVENT_H
 #define U_GEANTEVENT_H
 
@@ -38,32 +36,25 @@ namespace uLib {
 
 class GeantEventData {
 public:
-    uLibGetMacro      (EventID, Id_t    )
+uLibGetMacro(EventID, Id_t) uLibGetMacro(Momentum, Scalarf)
-    uLibGetMacro      (Momentum,Scalarf )
+    uLibConstRefMacro(GenPos, Vector3f) uLibConstRefMacro(GenDir, Vector3f)
-    uLibConstRefMacro (GenPos,  Vector3f)
+        uLibConstRefMacro(ChEvents, Vector<ChamberHitEventData>)
-    uLibConstRefMacro (GenDir,  Vector3f)
-    uLibConstRefMacro (ChEvents,Vector<ChamberHitEventData>)
 
-private:
+            private : friend class GeantEvent;
-        friend class GeantEvent;
+  Id_t m_EventID;
-    Id_t     m_EventID;
+  Scalarf m_Momentum;
-    Scalarf  m_Momentum;
+  Vector3f m_GenPos;
-    Vector3f m_GenPos;
+  Vector3f m_GenDir;
-    Vector3f m_GenDir;
+  Vector<ChamberHitEventData> m_ChEvents;
-    Vector<ChamberHitEventData> m_ChEvents;
 };
 
 class GeantEvent {
 public:
-    uLibSetMacro (EventID, Id_t    )
+  uLibSetMacro(EventID, Id_t) uLibSetMacro(Momentum, Scalarf)
-    uLibSetMacro (Momentum,Scalarf )
+      uLibRefMacro(GenPos, Vector3f) uLibRefMacro(GenDir, Vector3f)
-    uLibRefMacro (GenPos,  Vector3f)
+          uLibRefMacro(ChEvents, Vector<ChamberHitEventData>)
-    uLibRefMacro (GenDir,  Vector3f)
-    uLibRefMacro (ChEvents,Vector<ChamberHitEventData>)
 };
 
-
+} // namespace uLib
-}
-
 
 #endif // GEANTEVENT_H

src/Math/CMakeLists.txt

@@ -54,7 +54,7 @@ endif()
 
 
 install(TARGETS ${libname}
-        EXPORT "${PROJECT_NAME}Targets"
+        EXPORT "uLibTargets"
         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 

src/Math/VoxRaytracer.h

@@ -63,9 +63,16 @@ public:
 
     inline size_t Count() const { return this->m_Count; }
 
+    inline size_t size() const { return this->m_Count; }
+
     inline const Scalarf &TotalLength() const { return this->m_TotalLength; }
 
-    inline void SetCount(size_t c) { this->m_Count = c; }
+    inline void SetCount(size_t c) {
+      this->m_Count = c;
+      if (this->m_Data.size() != c) {
+        this->m_Data.resize(c);
+      }
+    }
 
     inline void SetTotalLength(Scalarf tl) { this->m_TotalLength = tl; }
 

src/Math/testing/VoxRaytracerTestExtended.cpp

@@ -48,7 +48,7 @@ int main() {
 
   Raytracer rt(img);
 
-  const size_t NUM_RAYS = 1000000;
+  const size_t NUM_RAYS = 100000;
   std::cout << "Generating " << NUM_RAYS
             << " random ray pairs across a 100x100x100 grid...\n";
 

src/ParticlePhysics/Geant/Makefile.am

@@ -1,14 +0,0 @@
-include $(top_srcdir)/Common.am
-
-library_includedir = $(includedir)/libmutom-${PACKAGE_VERSION}/ParticlePhysics/Geant
-
-library_include_HEADERS =
-
-_PPGEANT_SOURCES =
-
-
-
-noinst_LTLIBRARIES = libmutomppgeant.la
-libmutomppgeant_la_SOURCES = ${_PPGEANT_SOURCES}
-
-

src/Python/CMakeLists.txt

@@ -25,7 +25,7 @@ target_include_directories(uLib_python PRIVATE
 
 # Install uLib_python within the uLib install target
 install(TARGETS uLib_python
-        EXPORT "${PROJECT_NAME}Targets"
+        EXPORT "uLibTargets"
         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib
         ARCHIVE DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib

src/Root/CMakeLists.txt

@@ -56,7 +56,7 @@ set_target_properties(${libname} PROPERTIES
 target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
-        EXPORT "${PROJECT_NAME}Targets"
+        EXPORT "uLibTargets"
         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 

src/Vtk/CMakeLists.txt

@@ -1,23 +1,31 @@
 set(HEADERS uLibVtkInterface.h
             uLibVtkViewer.h
-            vtkContainerBox.h
+            vtkContainerBox.h)
-            vtkMuonScatter.h
-            vtkStructuredGrid.h
-            vtkVoxRaytracerRepresentation.h
-            vtkVoxImage.h)
 
 set(SOURCES uLibVtkInterface.cxx
             uLibVtkViewer.cpp
-            vtkContainerBox.cpp
+            vtkContainerBox.cpp)
-            vtkMuonScatter.cxx
+
-            vtkStructuredGrid.cpp
+## Pull in Math VTK wrappers (sets MATH_SOURCES / MATH_HEADERS)
-            vtkVoxRaytracerRepresentation.cpp
+add_subdirectory(Math)
-            vtkVoxImage.cpp)
+list(APPEND SOURCES ${MATH_SOURCES})
+list(APPEND HEADERS ${MATH_HEADERS})
+
+## Pull in HEP/Detectors VTK wrappers (sets HEP_DETECTORS_SOURCES / HEADERS)
+add_subdirectory(HEP/Detectors)
+list(APPEND SOURCES ${HEP_DETECTORS_SOURCES})
+list(APPEND HEADERS ${HEP_DETECTORS_HEADERS})
+
+## Pull in HEP/MuonTomography VTK wrappers (sets HEP_MUONTOMOGRAPHY_SOURCES / HEADERS)
+add_subdirectory(HEP/MuonTomography)
+list(APPEND SOURCES ${HEP_MUONTOMOGRAPHY_SOURCES})
+list(APPEND HEADERS ${HEP_MUONTOMOGRAPHY_HEADERS})
 
 set(LIBRARIES Eigen3::Eigen
               ${ROOT_LIBRARIES}
               ${VTK_LIBRARIES}
-              ${PACKAGE_LIBPREFIX}Math)
+              ${PACKAGE_LIBPREFIX}Math
+              ${PACKAGE_LIBPREFIX}Detectors)
 
 if(USE_CUDA)
   find_package(CUDAToolkit REQUIRED)
@@ -35,11 +43,14 @@ set_target_properties(${libname} PROPERTIES
 target_link_libraries(${libname} ${LIBRARIES})
 
 install(TARGETS ${libname}
-        EXPORT "${PROJECT_NAME}Targets"
+        EXPORT "uLibTargets"
         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 
 install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk)
+install(FILES ${MATH_HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk/Math)
+install(FILES ${HEP_DETECTORS_HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk/HEP/Detectors)
+install(FILES ${HEP_MUONTOMOGRAPHY_HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk/HEP/MuonTomography)
 
 if(BUILD_TESTING)
   include(uLibTargetMacros)

src/Vtk/HEP/Detectors/CMakeLists.txt

@@ -0,0 +1,22 @@
+
+################################################################################
+##### Vtk/HEP/Detectors - VTK wrappers for HEP Detectors objects ##############
+################################################################################
+
+## Sources and headers are exported to parent scope so they get compiled
+## into the single mutomVtk shared library.
+
+set(HEP_DETECTORS_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkMuonScatter.cxx
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkMuonEvent.cxx
+    PARENT_SCOPE)
+
+set(HEP_DETECTORS_HEADERS
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkMuonScatter.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkMuonEvent.h
+    PARENT_SCOPE)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Vtk/HEP/Detectors/testing/CMakeLists.txt

@@ -0,0 +1,14 @@
+# TESTS
+set(TESTS
+    vtkMuonScatterTest
+)
+
+set(LIBRARIES
+    ${PACKAGE_LIBPREFIX}Core
+    ${PACKAGE_LIBPREFIX}Detectors
+    ${PACKAGE_LIBPREFIX}Vtk
+    ${VTK_LIBRARIES}
+    Boost::unit_test_framework
+)
+
+uLib_add_tests(VtkDetectors)

src/Vtk/HEP/Detectors/testing/vtkMuonScatterTest.cpp

@@ -23,53 +23,40 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
+#include "HEP/Detectors/MuonScatter.h"
 
+#include "Vtk/uLibVtkViewer.h"
 
-
+#define BOOST_TEST_MODULE VtkMuonScatterTest
-#include "Math/TriangleMesh.h"
+#include <boost/test/unit_test.hpp>
-#include "Vtk/vtkTriangleMesh.h"
-#include "testing-prototype.h"
 
 using namespace uLib;
 
+BOOST_AUTO_TEST_CASE(vtkMuonScatterTest) {
+  MuonScatter event;
+  event.LineIn().direction << 0, -1, 1, 0;
+  event.LineIn().origin << 0, 1, -1, 1;
 
-int main()
+  event.LineOut().direction << 0, -1, 0, 0;
-{
+  event.LineOut().origin << 0, -1, 0, 1;
-    BEGIN_TESTING(Vtk Triangle Mesh);
 
-//    {   // SIMPLE TESTS //
+  Vtk::vtkMuonScatter v_event(event);
+  v_event.AddPocaPoint(HPoint3f(0, 0, 0));
 
+  v_event.SaveToXMLFile("vtk_testing_muonevent.vtp");
 
-//        TriangleMesh mesh;
+  if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
+    Vtk::Viewer viewer;
 
-//        mesh.AddPoint(Vector3f(0,0,0));
+    //    Vtk::Tie<Vtk::vtkMuonScatter> tms;
-//        mesh.AddPoint(Vector3f(0,1,0));
+    //    tms.DoAction();
-//        mesh.AddPoint(Vector3f(1,0,0));
+    //    Vtk::Tie<Vtk::Viewer> vms;
+    //    vms.DoAction();
 
-//        mesh.AddTriangle(Vector3i(0,1,2));
+    viewer.AddPuppet(v_event);
+    viewer.Start();
+  }
 
-//        mesh.PrintSelf(std::cout);
+  BOOST_CHECK(true); // reached here without crash
-
-
-//        vtkTriangleMesh v_mesh(mesh);
-//        v_mesh.Update();
-
-//        TestingRenderWidow(&v_mesh);
-//    }
-
-    {   // SIMPLE TESTS //
-
-        TriangleMesh mesh;
-
-        vtkTriangleMesh v_mesh(mesh);
-
-        v_mesh.ReadFromStlFile("prova.stl");
-
-        mesh.PrintSelf(std::cout);
-
-        TestingRenderWidow(&v_mesh);
-    }
-
-
-    END_TESTING;
 }

src/Vtk/HEP/Detectors/vtkMuonEvent.cxx

@@ -0,0 +1,145 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 "Math/Dense.h"
+#include "Vtk/HEP/Detectors/vtkMuonEvent.h"
+
+namespace uLib {
+namespace Vtk {
+
+///// CALLBACK /////////////////////////////////////////////////////////////////
+
+class vtkWidgetCallback : public vtkCommand {
+public:
+  static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
+  void SetParent(uLib::Vtk::vtkMuonEvent *parent) { this->parent = parent; }
+  virtual void Execute(vtkObject *caller, unsigned long, void *) {
+    vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
+    vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget *>(caller);
+    widget->GetTransform(t);
+    // parent->SetTransform(t);
+    // std::cout << "event\n";
+  }
+
+private:
+  uLib::Vtk::vtkMuonEvent *parent;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+/////  VTK MUON EVENT  /////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+vtkMuonEvent::vtkMuonEvent(MuonEventData &content)
+    : m_PolyData(NULL), m_Appender(vtkAppendPolyData::New()),
+      content(&content) {
+  InstallPipe();
+}
+
+vtkMuonEvent::vtkMuonEvent(const MuonEventData &content)
+    : m_PolyData(NULL), m_Appender(vtkAppendPolyData::New()),
+      content(const_cast<MuonEventData *>(&content)) {
+  InstallPipe();
+}
+
+vtkMuonEvent::~vtkMuonEvent() {}
+
+vtkMuonEvent::Content &vtkMuonEvent::GetContent() { return *content; }
+
+void vtkMuonEvent::PrintSelf(std::ostream &o) const {
+  o << "..:: MuonEvent ::..\n"
+       "\t[in]  Origin    > "
+    << content->LineIn().origin.transpose() << "\n"
+    << "\t[in]  Direction > " << content->LineIn().direction.transpose() << "\n"
+    << "\t[out] Origin    > " << content->LineOut().origin.transpose() << "\n"
+    << "\t[out] Direction > " << content->LineOut().direction.transpose()
+    << "\n"
+    << "\tMomentum        > " << content->GetMomentum() << "\n"
+    << "...................\n";
+}
+
+void vtkMuonEvent::InstallPipe() {
+
+  vtkAppendPolyData *appender = m_Appender;
+  vtkSmartPointer<vtkPolyDataMapper> mapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
+
+  if (content) {
+    vtkSmartPointer<vtkLineSource> line_in =
+        vtkSmartPointer<vtkLineSource>::New();
+    vtkSmartPointer<vtkLineSource> line_out =
+        vtkSmartPointer<vtkLineSource>::New();
+
+    float distance =
+        (content->LineIn().origin - content->LineOut().origin).norm() / 10;
+
+    HPoint3f pt;
+    pt = content->LineIn().origin;
+    line_in->SetPoint1(pt(0), pt(1), pt(2));
+    pt = content->LineIn().origin + content->LineIn().direction * distance;
+    line_in->SetPoint2(pt(0), pt(1), pt(2));
+    pt = content->LineOut().origin;
+    line_out->SetPoint1(pt(0), pt(1), pt(2));
+    pt = content->LineOut().origin + content->LineOut().direction * distance;
+    line_out->SetPoint2(pt(0), pt(1), pt(2));
+
+    appender->AddInputConnection(line_in->GetOutputPort());
+    appender->AddInputConnection(line_out->GetOutputPort());
+  }
+
+  appender->Update();
+  mapper->SetInputConnection(appender->GetOutputPort());
+  mapper->Update();
+
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+  actor->SetMapper(mapper);
+  this->SetProp(actor);
+}
+
+vtkPolyData *vtkMuonEvent::GetPolyData() const {
+  return m_Appender->GetOutput();
+}
+
+void vtkMuonEvent::AddPocaPoint(HPoint3f poca) {
+  m_Poca = poca;
+  vtkSmartPointer<vtkSphereSource> sphere =
+      vtkSmartPointer<vtkSphereSource>::New();
+  float size =
+      (content->LineIn().origin - content->LineOut().origin).head(3).norm();
+  size /= 100;
+  sphere->SetRadius(size);
+  sphere->SetCenter(poca(0), poca(1), poca(2));
+  sphere->Update();
+  m_Appender->AddInputConnection(sphere->GetOutputPort());
+  m_Appender->Update();
+}
+
+HPoint3f vtkMuonEvent::GetPocaPoint() { return m_Poca; }
+
+} // namespace Vtk
+} // namespace uLib

src/Vtk/HEP/Detectors/vtkMuonEvent.h

@@ -23,17 +23,15 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef VTKMUONEVENT_H
 #define VTKMUONEVENT_H
 
+#include <vtkActor.h>
+#include <vtkAppendPolyData.h>
+#include <vtkLineSource.h>
+#include <vtkPolyDataMapper.h>
 #include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
-#include <vtkAppendPolyData.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkLineSource.h>
-#include <vtkActor.h>
 
 #include <vtk3DWidget.h>
 #include <vtkBoxWidget.h>
@@ -45,50 +43,45 @@
 
 #include "Math/Dense.h"
 
-#include "uLibVtkInterface.h"
+#include "HEP/Detectors/MuonEvent.h"
-#include "Detectors/MuonEvent.h"
+#include "Vtk/uLibVtkInterface.h"
-
-
-
 
 namespace uLib {
+namespace Vtk {
+
+class vtkMuonEvent : public Puppet, public Polydata {
+  typedef MuonEventData Content;
 
-class vtkMuonEvent : public Abstract::uLibVtkPolydata {
-    typedef MuonEventData Content;
 public:
-    vtkMuonEvent(const MuonEventData &content);
+  vtkMuonEvent(const MuonEventData &content);
-    vtkMuonEvent(MuonEventData &content);
+  vtkMuonEvent(MuonEventData &content);
-    ~vtkMuonEvent();
+  ~vtkMuonEvent();
 
-    Content& GetContent();
+  Content &GetContent();
 
-    void PrintSelf(std::ostream &o) const;
+  void PrintSelf(std::ostream &o) const;
 
-    virtual vtkProp *GetProp();
+  virtual vtkPolyData *GetPolyData() const;
 
-    virtual vtkPolyData* GetPolyData() const;
+  void AddPocaPoint(HPoint3f poca);
 
-    void AddPocaPoint(HPoint3f poca);
+  HPoint3f GetPocaPoint();
-
-    HPoint3f GetPocaPoint();
-
-    void vtkStartInteractive();
 
+  void vtkStartInteractive();
 
 private:
-    void InstallPipe();
+  void InstallPipe();
 
-    vtkMuonEvent::Content *content;
+  vtkMuonEvent::Content *content;
-    vtkPolyData           *m_PolyData;
+  vtkPolyData *m_PolyData;
-    vtkActor              *m_Prop;
 
-    vtkAppendPolyData     *m_Appender;
+  vtkAppendPolyData *m_Appender;
-    vtkBoxWidget          *m_WidgetIN;
+  vtkBoxWidget *m_WidgetIN;
-    vtkBoxWidget          *m_WidgetOUT;
+  vtkBoxWidget *m_WidgetOUT;
-    HPoint3f               m_Poca;
+  HPoint3f m_Poca;
 };
 
+} // namespace Vtk
+} // namespace uLib
 
-}
+#endif // VTKMUONEVENT_H
-
-#endif // VTKMUONSCATTER_H

src/Vtk/HEP/Detectors/vtkMuonScatter.cxx

@@ -0,0 +1,144 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 "Math/Dense.h"
+#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
+
+namespace uLib {
+namespace Vtk {
+
+////////////////////////////////////////////////////////////////////////////////
+/////  VTK MUON Scatter  ///////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+vtkMuonScatter::vtkMuonScatter(MuonScatter &content)
+    : m_Content(&content), m_LineIn(vtkLineSource::New()),
+      m_LineOut(vtkLineSource::New()), m_PolyData(vtkPolyData::New()),
+      m_SpherePoca(NULL) {
+  InstallPipe();
+}
+
+vtkMuonScatter::vtkMuonScatter(const MuonScatter &content)
+    : m_Content(const_cast<MuonScatter *>(&content)),
+      m_LineIn(vtkLineSource::New()), m_LineOut(vtkLineSource::New()),
+      m_PolyData(vtkPolyData::New()), m_SpherePoca(NULL) {
+  InstallPipe();
+}
+
+vtkMuonScatter::~vtkMuonScatter() {
+  m_LineIn->Delete();
+  m_LineOut->Delete();
+  if (m_SpherePoca)
+    m_SpherePoca->Delete();
+}
+
+vtkMuonScatter::Content &vtkMuonScatter::GetContent() { return *m_Content; }
+
+void vtkMuonScatter::PrintSelf(std::ostream &o) const {}
+
+void vtkMuonScatter::InstallPipe() {
+  if (m_Content) {
+    vtkLineSource *line_in = m_LineIn;
+    vtkLineSource *line_out = m_LineOut;
+
+    float distance =
+        (m_Content->LineIn().origin - m_Content->LineOut().origin).norm() / 10;
+
+    HPoint3f pt;
+    pt = m_Content->LineIn().origin;
+    line_in->SetPoint1(pt(0), pt(1), pt(2));
+    pt = m_Content->LineIn().origin + m_Content->LineIn().direction * distance;
+    line_in->SetPoint2(pt(0), pt(1), pt(2));
+    pt = m_Content->LineOut().origin;
+    line_out->SetPoint1(pt(0), pt(1), pt(2));
+    pt =
+        m_Content->LineOut().origin + m_Content->LineOut().direction * distance;
+    line_out->SetPoint2(pt(0), pt(1), pt(2));
+  }
+
+  vtkSmartPointer<vtkPolyDataMapper> mapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
+  mapper->SetInputConnection(m_LineIn->GetOutputPort());
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+  actor->SetMapper(mapper);
+  this->SetProp(actor);
+
+  mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+  mapper->SetInputConnection(m_LineOut->GetOutputPort());
+  actor = vtkSmartPointer<vtkActor>::New();
+  actor->SetMapper(mapper);
+  this->SetProp(actor);
+}
+
+vtkPolyData *vtkMuonScatter::GetPolyData() const {
+  vtkSmartPointer<vtkAppendPolyData> append =
+      vtkSmartPointer<vtkAppendPolyData>::New();
+  append->AddInputConnection(m_LineIn->GetOutputPort());
+  append->AddInputConnection(m_LineOut->GetOutputPort());
+  if (m_SpherePoca)
+    append->AddInputConnection(m_SpherePoca->GetOutputPort());
+  append->Update();
+  m_PolyData->DeepCopy(append->GetOutput());
+  return m_PolyData;
+}
+
+void vtkMuonScatter::AddPocaPoint(HPoint3f poca) {
+  vtkSphereSource *sphere = vtkSphereSource::New();
+  float size =
+      (m_Content->LineIn().origin - m_Content->LineOut().origin).head(3).norm();
+  size /= 100;
+  sphere->SetRadius(size);
+  sphere->SetCenter(poca(0), poca(1), poca(2));
+  sphere->Update();
+  m_SpherePoca = sphere;
+
+  vtkSmartPointer<vtkPolyDataMapper> mapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
+  mapper->SetInputConnection(m_SpherePoca->GetOutputPort());
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+  actor->SetMapper(mapper);
+  this->SetProp(actor);
+}
+
+HPoint3f vtkMuonScatter::GetPocaPoint() {
+  double center[3];
+  if (m_SpherePoca) {
+    m_SpherePoca->GetCenter(center);
+    return HPoint3f(center[0], center[1], center[2]);
+  } else {
+    return HPoint3f(0, 0, 0);
+  }
+}
+
+void vtkMuonScatter::ConnectInteractor(vtkRenderWindowInteractor *interactor) {
+  // TODO
+}
+
+} // namespace Vtk
+} // namespace uLib

src/Vtk/HEP/Detectors/vtkMuonScatter.h

@@ -23,18 +23,16 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef VTKMUONSCATTER_H
 #define VTKMUONSCATTER_H
 
-#include <vtkVersion.h>
+#include <vtkActor.h>
+#include <vtkAppendPolyData.h>
+#include <vtkLineSource.h>
+#include <vtkPolyDataMapper.h>
 #include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
-#include <vtkAppendPolyData.h>
+#include <vtkVersion.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkLineSource.h>
-#include <vtkActor.h>
 
 #include <vtk3DWidget.h>
 #include <vtkBoxWidget.h>
@@ -46,8 +44,8 @@
 
 #include "Math/Dense.h"
 
-#include "uLibVtkInterface.h"
+#include "HEP/Detectors/MuonScatter.h"
-#include "Detectors/MuonScatter.h"
+#include "Vtk/uLibVtkInterface.h"
 
 class vtkRenderWindowInteractor;
 
@@ -55,40 +53,40 @@ namespace uLib {
 namespace Vtk {
 
 class vtkMuonScatter : public Puppet, public Polydata {
-    typedef MuonScatter Content;
+  typedef MuonScatter Content;
+
 public:
+  vtkMuonScatter(const MuonScatter &content);
+  vtkMuonScatter(MuonScatter &content);
 
-    vtkMuonScatter(const MuonScatter &content);
+  ~vtkMuonScatter();
-    vtkMuonScatter(MuonScatter &content);
 
-    ~vtkMuonScatter();
+  Content &GetContent();
 
-    Content &GetContent();
+  void PrintSelf(std::ostream &o) const;
 
-    void PrintSelf(std::ostream &o) const;
+  virtual vtkPolyData *GetPolyData() const;
 
-    virtual vtkPolyData* GetPolyData() const;
+  void AddPocaPoint(HPoint3f poca);
 
-    void AddPocaPoint(HPoint3f poca);
+  HPoint3f GetPocaPoint();
 
-    HPoint3f GetPocaPoint();
+  void vtkStartInteractive();
-
-    void vtkStartInteractive();
 
 protected:
-    void ConnectInteractor(vtkRenderWindowInteractor *interactor);
+  void ConnectInteractor(vtkRenderWindowInteractor *interactor);
 
 private:
-    void InstallPipe();
+  void InstallPipe();
 
-    vtkMuonScatter::Content *m_Content;
+  vtkMuonScatter::Content *m_Content;
-    vtkLineSource           *m_LineIn;
+  vtkLineSource *m_LineIn;
-    vtkLineSource           *m_LineOut;
+  vtkLineSource *m_LineOut;
-    vtkSphereSource         *m_SpherePoca;
+  vtkSphereSource *m_SpherePoca;
-    vtkPolyData             *m_PolyData;
+  vtkPolyData *m_PolyData;
 };
 
-} // vtk
+} // namespace Vtk
-} // uLib
+} // namespace uLib
 
 #endif // VTKMUONSCATTER_H

src/Vtk/HEP/MuonTomography/CMakeLists.txt

@@ -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()

src/Vtk/HEP/MuonTomography/testing/CMakeLists.txt

@@ -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)

src/Vtk/HEP/MuonTomography/testing/vtkVoxRaytracerTest.cpp

@@ -23,69 +23,55 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 #include <vtkBoxWidget.h>
-#include <vtkSmartPointer.h>
 #include <vtkCommand.h>
+#include <vtkSmartPointer.h>
 
-
-#include <Detectors/MuonScatter.h>
-#include <Math/VoxRaytracer.h>
-
-#include "Vtk/vtkMuonScatter.h"
-#include "Vtk/vtkStructuredGrid.h"
-#include "Vtk/vtkVoxRaytracerRepresentation.h"
-#include "Vtk/uLibVtkViewer.h"
-
-// remove
 #include <vtkCornerAnnotation.h>
 
-#include "testing-prototype.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 {
-
-class vtkWidgetCallback : public vtkCommand
-{
 public:
   static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
 
-  void SetTracer(Vtk::vtkVoxRaytracerRepresentation *parent)
+  void SetTracer(Vtk::vtkVoxRaytracerRepresentation *parent) {
-  {
+    this->vtk_raytr = parent;
-      this->vtk_raytr = parent;
   }
 
-  void SetMuon  (uLib::MuonScatter *muon) { this->muon = muon; }
+  void SetMuon(uLib::MuonScatter *muon) { this->muon = muon; }
 
-  void SetAnnotation ( vtkCornerAnnotation *annotation) {
+  void SetAnnotation(vtkCornerAnnotation *annotation) {
-      this->annotation = annotation;
+    this->annotation = annotation;
   }
 
-  virtual void Execute(vtkObject *caller, unsigned long, void*)
+  virtual void Execute(vtkObject *caller, unsigned long, void *) {
-  {
+    char str[40];
-      char str[40];
+    vtk_raytr->SetMuon(*muon);
-      vtk_raytr->SetMuon(*muon);
+    if (annotation) {
-      if(annotation)
+      sprintf(str, "total length = %f", vtk_raytr->GetRay().TotalLength());
-      {
+      annotation->SetText(1, str);
-          sprintf(str,"total length = %f",vtk_raytr->GetRay().TotalLength());
+      for (int i = 0; i < vtk_raytr->GetRay().size(); ++i) {
-          annotation->SetText(1,str);
+        std::cout << "L[" << i << "] = " << vtk_raytr->GetRay().Data().at(i).L
-          for(int i=0; i<vtk_raytr->GetRay().Data().size(); ++i)
+                  << "\n";
-          {
-              std::cout << "L[" << i << "] = "
-                        << vtk_raytr->GetRay().Data().at(i).L << "\n";
-          }
-          std::cout << "\n";
       }
+      std::cout << "\n";
+    }
   }
 
 private:
-  vtkWidgetCallback() :
+  vtkWidgetCallback() : vtk_raytr(NULL), muon(NULL), annotation(NULL) {}
-      vtk_raytr(NULL),
-      muon(NULL),
-      annotation(NULL) {}
 
   uLib::VoxRaytracer *raytracer;
   Vtk::vtkVoxRaytracerRepresentation *vtk_raytr;
@@ -93,50 +79,40 @@ private:
   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));
 
-int main()
+  Vtk::vtkStructuredGrid v_grid(grid);
-{
-    BEGIN_TESTING(vtk VoxRaytracer);
 
+  // voxraytracer //
+  VoxRaytracer rt(grid);
+  HPoint3f pt;
+  rt.GetEntryPoint(muon.LineIn(), pt);
+  std::cout << pt.transpose() << "\n";
 
-    // muon scatter //
+  Vtk::vtkVoxRaytracerRepresentation v_rt(rt);
-    MuonScatter muon;
+  v_rt.SetMuon(muon);
-    muon.LineIn().origin << -6, 12, -6, 1;
+  v_rt.SetRayColor(Vector4f(1, 0, 0, 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);
+  if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
-
+    // renderer //
-
-    // 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));
-
-    //    // renderer //
     Vtk::Viewer viewer;
 
     // widget //
     vtkBoxWidget *widget = v_grid.GetWidget();
 
-
     vtkWidgetCallback *cbk = vtkWidgetCallback::New();
     cbk->SetTracer(&v_rt);
     cbk->SetMuon(&muon);
@@ -150,7 +126,7 @@ int main()
     viewer.AddPuppet(v_rt);
     viewer.AddPuppet(v_muon);
     viewer.Start();
+  }
 
-
+  BOOST_CHECK(v_rt.GetRay().Count() > 0);
-    END_TESTING;
 }

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.cpp

@@ -27,12 +27,12 @@
 #include "config.h"
 #endif
 
-#include "vtkVoxRaytracerRepresentation.h"
+#include "Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h"
 
 #include "Math/VoxRaytracer.h"
 
-// #include "vtkMuonEvent.h"
+// #include "Vtk/HEP/Detectors/vtkMuonEvent.h"
-#include "vtkMuonScatter.h"
+#include "Vtk/HEP/Detectors/vtkMuonScatter.h"
 
 namespace uLib {
 namespace Vtk {
@@ -114,12 +114,10 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
   m_Line3->SetPoint1(pt1(0), pt1(1), pt1(2));
   m_Line3->SetPoint2(pt2(0), pt2(1), pt2(2));
 
-  // Create a vtkPoints object and store the points in it
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->InsertNextPoint(pt1(0), pt1(1), pt1(2));
   points->InsertNextPoint(pt2(0), pt2(1), pt2(2));
 
-  // Create a cell array to store the lines in and add the lines to it
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
 
   vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
@@ -127,19 +125,16 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon) {
   line->GetPointIds()->SetId(1, 1);
   lines->InsertNextCell(line);
 
-  // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> linesPolyData =
       vtkSmartPointer<vtkPolyData>::New();
-
-  // Add the points to the dataset
   linesPolyData->SetPoints(points);
-
-  // Add the lines to the dataset
   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());
@@ -177,15 +172,12 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca) {
   m_Line3->SetPoint1(pt1(0), pt1(1), pt1(2));
   m_Line3->SetPoint2(pt2(0), pt2(1), pt2(2));
 
-  // Create a vtkPoints object and store the points in it
   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));
 
-  // Create a cell array to store the lines in and add the lines to it
   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);
@@ -193,19 +185,16 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca) {
     lines->InsertNextCell(line);
   }
 
-  // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> linesPolyData =
       vtkSmartPointer<vtkPolyData>::New();
-
-  // Add the points to the dataset
   linesPolyData->SetPoints(points);
-
-  // Add the lines to the dataset
   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());
@@ -263,9 +252,11 @@ void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray) {
     cube->Update();
 #if VTK_MAJOR_VERSION <= 5
     appender->AddInput(cube->GetOutput());
+#else
+    appender->AddInputData(cube->GetOutput());
 #endif
-    appender->Update();
   }
+  appender->Modified();
 }
 
 void vtkVoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba) {
@@ -294,21 +285,18 @@ void vtkVoxRaytracerRepresentation::InstallPipe() {
   append->AddInputConnection(m_Line1->GetOutputPort());
   append->AddInputConnection(m_Line2->GetOutputPort());
 
-  append->Update();
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
 
   mapper->SetInputConnection(append->GetOutputPort());
-  mapper->Update();
 
-  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+  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());
-  mapper->Update();
 
   m_RayLineActor->SetMapper(mapper);
   m_RayLineActor->GetProperty()->SetColor(1, 0, 0);
@@ -322,7 +310,6 @@ void vtkVoxRaytracerRepresentation::InstallPipe() {
 
   mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   mapper->SetInputConnection(polyfilter->GetOutputPort());
-  mapper->Update();
 
   vtkActor *vra = m_RayRepresentationActor;
   vra->SetMapper(mapper);

src/Vtk/HEP/MuonTomography/vtkVoxRaytracerRepresentation.h

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

src/Vtk/Math/CMakeLists.txt

@@ -0,0 +1,22 @@
+
+################################################################################
+##### Vtk/Math - VTK wrappers for Math module objects #########################
+################################################################################
+
+set(MATH_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkStructuredGrid.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkTriangleMesh.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkVoxImage.cpp
+    PARENT_SCOPE)
+
+set(MATH_HEADERS
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkHLineRepresentation.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkStructuredGrid.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkTriangleMesh.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/vtkVoxImage.h
+    PARENT_SCOPE)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()

src/Vtk/Math/testing/CMakeLists.txt

@@ -0,0 +1,18 @@
+# TESTS
+set(TESTS
+    vtkStructuredGridTest
+    vtkTriangleMeshTest
+    vtkVoxImageTest
+)
+
+set(LIBRARIES
+    ${PACKAGE_LIBPREFIX}Core
+    ${PACKAGE_LIBPREFIX}Math
+    ${PACKAGE_LIBPREFIX}Vtk
+    ${VTK_LIBRARIES}
+    Boost::unit_test_framework
+)
+
+uLib_add_tests(VtkMath)
+
+configure_file(capelluzzo.stl ${CMAKE_CURRENT_BINARY_DIR}/capelluzzo.stl COPYONLY)

src/Vtk/Math/testing/vtkStructuredGridTest.cpp

@@ -23,29 +23,26 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
+#include "Vtk/Math/vtkStructuredGrid.h"
-
-
 #include "Math/StructuredGrid.h"
-
-#include "Vtk/vtkStructuredGrid.h"
 #include "Vtk/uLibVtkViewer.h"
 
-#include "testing-prototype.h"
+#define BOOST_TEST_MODULE VtkStructuredGridTest
+#include <boost/test/unit_test.hpp>
 
 using namespace uLib;
 
-int main()
+BOOST_AUTO_TEST_CASE(vtkStructuredGridTest) {
-{
+  StructuredGrid grid(Vector3i(10, 10, 100));
+  grid.SetSpacing(Vector3f(3, 1, 1));
 
-    StructuredGrid grid(Vector3i(10,10,100));
+  Vtk::vtkStructuredGrid grid_viewer(grid);
-    grid.SetSpacing(Vector3f(3,1,1));
-
-    Vtk::vtkStructuredGrid grid_viewer(grid);
 
+  if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
     viewer.AddPuppet(grid_viewer);
     viewer.Start();
+  }
 
-    return 0;
+  BOOST_CHECK(grid_viewer.GetWidget() != nullptr);
 }

src/Vtk/Math/testing/vtkTriangleMeshTest.cpp

@@ -0,0 +1,71 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#include "Vtk/Math/vtkTriangleMesh.h"
+#include "Math/TriangleMesh.h"
+#include "Vtk/uLibVtkViewer.h"
+
+#define BOOST_TEST_MODULE VtkTriangleMeshTest
+#include <boost/test/unit_test.hpp>
+
+using namespace uLib;
+
+BOOST_AUTO_TEST_CASE(vtkTriangleMeshConstruction) {
+  TriangleMesh mesh;
+
+  mesh.AddPoint(Vector3f(0, 0, 0));
+  mesh.AddPoint(Vector3f(0, 1, 0));
+  mesh.AddPoint(Vector3f(1, 0, 0));
+  mesh.AddTriangle(Vector3i(0, 1, 2));
+
+  Vtk::vtkTriangleMesh v_mesh(mesh);
+  v_mesh.Update();
+
+  if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
+    Vtk::Viewer viewer;
+    viewer.AddPuppet(v_mesh);
+    viewer.Start();
+  }
+
+  BOOST_CHECK_EQUAL(mesh.Points().size(), 3u);
+  BOOST_CHECK_EQUAL(mesh.Triangles().size(), 1u);
+}
+
+BOOST_AUTO_TEST_CASE(vtkTriangleMeshConstruction2) {
+  TriangleMesh mesh;
+
+  Vtk::vtkTriangleMesh v_mesh(mesh);
+  v_mesh.ReadFromStlFile("capelluzzo.stl");
+  v_mesh.Update();
+
+  if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
+    Vtk::Viewer viewer;
+    viewer.AddPuppet(v_mesh);
+    viewer.Start();
+  }
+
+  BOOST_CHECK_EQUAL(mesh.Points().size(), 3u);
+  BOOST_CHECK_EQUAL(mesh.Triangles().size(), 1u);
+}

src/Vtk/Math/testing/vtkVoxImageTest.cpp

@@ -23,40 +23,37 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
+#include "Vtk/Math/vtkVoxImage.h"
-
+#include "Math/VoxImage.h"
-#include "Detectors/MuonScatter.h"
-#include "Vtk/vtkMuonScatter.h"
-
 #include "Vtk/uLibVtkViewer.h"
 
-#include "testing-prototype.h"
+#define BOOST_TEST_MODULE VtkVoxImageTest
+#include <boost/test/unit_test.hpp>
 
 using namespace uLib;
 
-int main()
+struct TestVoxel {
-{
+  Scalarf Value;
-    MuonScatter event;
+  unsigned int Count;
-    event.LineIn().direction <<   0, -1,  1,  0;
+};
-    event.LineIn().origin   <<    0,  1, -1,  1;
 
-    event.LineOut().direction <<  0, -1,  0,  0;
+BOOST_AUTO_TEST_CASE(vtkVoxImageConstruction) {
-    event.LineOut().origin <<     0, -1,  0,  1;
+  TestVoxel zero = {0, 0};
+  TestVoxel nonzero = {5.5f * 1e-6f, 100};
 
-    Vtk::vtkMuonScatter v_event(event);
+  VoxImage<TestVoxel> img(Vector3i(10, 10, 10));
-    v_event.AddPocaPoint(HPoint3f(0,0,0));
+  img.SetSpacing(Vector3f(3, 3, 3));
+  img.InitVoxels(zero);
+  img[Vector3i(3, 3, 3)] = nonzero;
 
-    v_event.SaveToXMLFile("vtk_testing_muonevent.vtp");
+  Vtk::vtkVoxImage vtk_img(img);
+  vtk_img.SaveToXMLFile("test_vtkvoximage.vti");
 
+  if (std::getenv("CTEST_PROJECT_NAME") == nullptr) {
     Vtk::Viewer viewer;
-
+    viewer.AddPuppet(vtk_img);
-//    Vtk::Tie<Vtk::vtkMuonScatter> tms;
-//    tms.DoAction();
-//    Vtk::Tie<Vtk::Viewer> vms;
-//    vms.DoAction();
-
-    viewer.AddPuppet(v_event);
     viewer.Start();
+  }
 
-    return 0;
+  BOOST_CHECK(vtk_img.GetImageData() != nullptr);
 }

src/Vtk/Math/vtkHLineRepresentation.h

@@ -23,30 +23,20 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef VTKHLINEREPRESENTATION_H
 #define VTKHLINEREPRESENTATION_H
 
-
-
 class vtkProp;
 class vtkPolyData;
 
-
 namespace uLib {
 
 class vtkHLineRepresentationDefault {
 
 public:
-    vtkHLineRepresentationDefault();
+  vtkHLineRepresentationDefault();
-
-
 };
 
-
+} // namespace uLib
-}
-
-
 
 #endif // VTKHLINEREPRESENTATION_H

src/Vtk/Math/vtkStructuredGrid.cpp

@@ -0,0 +1,114 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 "Math/StructuredGrid.h"
+#include "Vtk/Math/vtkStructuredGrid.h"
+
+namespace uLib {
+namespace Vtk {
+
+////////////////////////////////////////////////////////////////////////////////
+////// VTK STRUCTURED GRID /////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+vtkStructuredGrid::vtkStructuredGrid(Content &content)
+    : m_Content(&content), m_Actor(vtkActor::New()),
+      m_Widget(vtkBoxWidget::New()), m_Transform(vtkTransform::New()) {
+  vtkSmartPointer<vtkWidgetCallback> callback =
+      vtkSmartPointer<vtkWidgetCallback>::New();
+  callback->SetGrid(this);
+  m_Widget->AddObserver(vtkCommand::InteractionEvent, callback);
+
+  this->InstallPipe();
+}
+
+vtkStructuredGrid::~vtkStructuredGrid() {
+  m_Actor->Delete();
+  m_Widget->Delete();
+  m_Transform->Delete();
+}
+
+void vtkStructuredGrid::SetTransform(vtkTransform *t) {
+  vtkMatrix4x4 *vmat = t->GetMatrix();
+  Matrix4f mat;
+  for (int i = 0; i < 4; ++i)
+    for (int j = 0; j < 4; ++j)
+      mat(i, j) = vmat->GetElement(i, j);
+  m_Content->SetMatrix(mat);
+
+  vtkSmartPointer<vtkMatrix4x4> vmat2 = vtkSmartPointer<vtkMatrix4x4>::New();
+  mat = m_Content->GetWorldMatrix();
+  for (int i = 0; i < 4; ++i)
+    for (int j = 0; j < 4; ++j)
+      vmat2->SetElement(i, j, mat(i, j));
+  m_Transform->SetMatrix(vmat2);
+  m_Transform->Update();
+  this->Update();
+}
+
+vtkBoxWidget *vtkStructuredGrid::GetWidget() { return m_Widget; }
+
+void vtkStructuredGrid::Update() { m_Actor->GetMapper()->Update(); }
+
+void vtkStructuredGrid::InstallPipe() {
+  vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
+  vtkSmartPointer<vtkTransformPolyDataFilter> filter =
+      vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+
+  vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
+  Matrix4f mat = m_Content->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);
+  filter->SetTransform(m_Transform);
+  filter->SetInputConnection(cube->GetOutputPort());
+
+  Vector3i dims = m_Content->GetDims();
+  cube->SetBounds(0, dims(0), 0, dims(1), 0, dims(2));
+  cube->Update();
+  filter->Update();
+
+  vtkSmartPointer<vtkPolyDataMapper> mapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
+  mapper->SetInputConnection(filter->GetOutputPort());
+
+  m_Actor->SetMapper(mapper);
+  m_Actor->GetProperty()->SetRepresentationToSurface();
+  m_Actor->GetProperty()->SetEdgeVisibility(true);
+  m_Actor->GetProperty()->SetOpacity(0.4);
+  m_Actor->GetProperty()->SetAmbient(0.7);
+  this->Update();
+  m_Widget->SetProp3D(m_Actor);
+
+  this->SetProp(m_Actor);
+}
+
+} // namespace Vtk
+} // namespace uLib

src/Vtk/Math/vtkStructuredGrid.h

@@ -23,77 +23,70 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_VTKSTRUCTUREDGRID_H
 #define U_VTKSTRUCTUREDGRID_H
 
-#include <vtkLineSource.h>
+#include <vtkActor.h>
 #include <vtkBoundingBox.h>
 #include <vtkCubeSource.h>
-#include <vtkSmartPointer.h>
+#include <vtkLineSource.h>
 #include <vtkPolyDataMapper.h>
-#include <vtkActor.h>
 #include <vtkProperty.h>
+#include <vtkSmartPointer.h>
 
-#include <vtkTransform.h>
-#include <vtkTransformPolyDataFilter.h>
 #include <vtkBoxWidget.h>
 #include <vtkCommand.h>
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
 
 #include "Math/Dense.h"
 
-#include "uLibVtkInterface.h"
 #include "Math/StructuredGrid.h"
-
+#include "Vtk/uLibVtkInterface.h"
 
 namespace uLib {
 namespace Vtk {
 
 class vtkStructuredGrid : public Puppet {
-    typedef StructuredGrid Content;
+  typedef StructuredGrid Content;
+
 public:
+  vtkStructuredGrid(Content &content);
+  ~vtkStructuredGrid();
 
-    vtkStructuredGrid(Content &content);
+  void SetTransform(class vtkTransform *t);
-    ~vtkStructuredGrid();
 
-    void SetTransform(class vtkTransform *t);
+  class vtkBoxWidget *GetWidget();
-
-    class vtkBoxWidget * GetWidget();
-
-    void Update();
 
+  void Update();
 
 private:
-    void InstallPipe();
+  void InstallPipe();
 
-    class vtkWidgetCallback : public vtkCommand
+  class vtkWidgetCallback : public vtkCommand {
-    {
+  public:
-    public:
+    static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
-        static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
 
-        void SetGrid(uLib::Vtk::vtkStructuredGrid *grid) { this->grid = grid; }
+    void SetGrid(uLib::Vtk::vtkStructuredGrid *grid) { this->grid = grid; }
 
-        virtual void Execute(vtkObject *caller, unsigned long, void*)
+    virtual void Execute(vtkObject *caller, unsigned long, void *) {
-        {
+      vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
-          vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
+      vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget *>(caller);
-          vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
+      widget->GetTransform(t);
-          widget->GetTransform(t);
+      grid->SetTransform(t);
-          grid->SetTransform(t);
+    }
-        }
-    private:
-        uLib::Vtk::vtkStructuredGrid *grid;
-    };
 
-    vtkActor          *m_Actor;
+  private:
-    vtkBoxWidget      *m_Widget;
+    uLib::Vtk::vtkStructuredGrid *grid;
-    StructuredGrid    *m_Content;
+  };
-    vtkTransform      *m_Transform;
+
+  vtkActor *m_Actor;
+  vtkBoxWidget *m_Widget;
+  StructuredGrid *m_Content;
+  vtkTransform *m_Transform;
 };
 
-
+} // namespace Vtk
-} // vtk
+} // namespace uLib
-} // uLib
-
 
 #endif // VTKSTRUCTUREDGRID_H

src/Vtk/Math/vtkTriangleMesh.cpp

@@ -0,0 +1,166 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 <vtkSmartPointer.h>
+
+#include <vtkOBJReader.h>
+#include <vtkPolyDataReader.h>
+#include <vtkSTLReader.h>
+#include <vtkXMLPolyDataReader.h>
+
+#include <vtkActor.h>
+#include <vtkCellArray.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper.h>
+
+#include "Vtk/Math/vtkTriangleMesh.h"
+#include <iostream>
+
+namespace uLib {
+namespace Vtk {
+
+void vtkTriangleMesh::vtk2uLib_update() {
+  vtkIdType number_of_points = m_Poly->GetNumberOfPoints();
+  vtkIdType number_of_triangles = m_Poly->GetNumberOfPolys();
+
+  std::cout << "//////\n"
+            << "number of points = " << number_of_points << "\n"
+            << "number of polys  = " << number_of_triangles << "\n"
+            << "//////\n";
+
+  m_content.Points().resize(number_of_points);
+  for (int i = 0; i < number_of_points; ++i) {
+    double *point = m_Poly->GetPoint(i);
+    m_content.Points()[i](0) = point[0];
+    m_content.Points()[i](1) = point[1];
+    m_content.Points()[i](2) = point[2];
+  }
+
+  m_content.Triangles().resize(number_of_triangles);
+  m_Poly->GetPolys()->InitTraversal();
+  vtkSmartPointer<vtkIdList> idList = vtkSmartPointer<vtkIdList>::New();
+  for (int i = 0; i < number_of_triangles; ++i) {
+    m_Poly->GetPolys()->GetNextCell(idList);
+    m_content.Triangles()[i](0) = idList->GetId(0);
+    m_content.Triangles()[i](1) = idList->GetId(1);
+    m_content.Triangles()[i](2) = idList->GetId(2);
+  }
+  m_Poly->Modified();
+  m_Actor->GetMapper()->Update();
+}
+
+void vtkTriangleMesh::uLib2vtk_update() {
+  vtkIdType number_of_points = m_content.Points().size();
+  vtkIdType number_of_triangles = m_content.Triangles().size();
+
+  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+  points->SetNumberOfPoints(number_of_points);
+  for (vtkIdType i = 0; i < number_of_points; i++) {
+    double x, y, z;
+    x = m_content.Points().at(i)(0);
+    y = m_content.Points().at(i)(1);
+    z = m_content.Points().at(i)(2);
+    points->SetPoint(i, x, y, z);
+  }
+
+  vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
+  for (vtkIdType i = 0; i < number_of_triangles; i++) {
+    vtkIdType a, b, c;
+    a = m_content.Triangles().at(i)(0);
+    b = m_content.Triangles().at(i)(1);
+    c = m_content.Triangles().at(i)(2);
+    polys->InsertNextCell(3);
+    polys->InsertCellPoint(a);
+    polys->InsertCellPoint(b);
+    polys->InsertCellPoint(c);
+  }
+
+  m_Poly->SetPoints(points);
+  m_Poly->SetPolys(polys);
+  m_Poly->Modified();
+  m_Actor->GetMapper()->Update();
+}
+
+// -------------------------------------------------------------------------- //
+
+vtkTriangleMesh::vtkTriangleMesh(vtkTriangleMesh::Content &content)
+    : m_content(content), m_Poly(vtkPolyData::New()), m_Actor(vtkActor::New()) {
+  vtkSmartPointer<vtkPolyDataMapper> mapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
+  mapper->SetInputData(m_Poly);
+  m_Actor->SetMapper(mapper);
+  this->SetProp(m_Actor);
+}
+
+vtkTriangleMesh::~vtkTriangleMesh() {
+  m_Poly->Delete();
+  m_Actor->Delete();
+}
+
+void vtkTriangleMesh::ReadFromFile(const char *filename) {
+  vtkSmartPointer<vtkPolyDataReader> reader =
+      vtkSmartPointer<vtkPolyDataReader>::New();
+  reader->SetFileName(filename);
+  reader->Update();
+  m_Poly->DeepCopy(reader->GetOutput());
+  vtk2uLib_update();
+}
+
+void vtkTriangleMesh::ReadFromXMLFile(const char *filename) {
+  vtkSmartPointer<vtkXMLPolyDataReader> reader =
+      vtkSmartPointer<vtkXMLPolyDataReader>::New();
+  reader->SetFileName(filename);
+  reader->Update();
+  m_Poly->DeepCopy(reader->GetOutput());
+  vtk2uLib_update();
+}
+
+void vtkTriangleMesh::ReadFromObjFile(const char *filename) {
+  vtkSmartPointer<vtkOBJReader> reader = vtkSmartPointer<vtkOBJReader>::New();
+  reader->SetFileName(filename);
+  reader->Update();
+  m_Poly->DeepCopy(reader->GetOutput());
+  vtk2uLib_update();
+}
+
+void vtkTriangleMesh::ReadFromStlFile(const char *filename) {
+  vtkSmartPointer<vtkSTLReader> reader = vtkSmartPointer<vtkSTLReader>::New();
+  reader->SetFileName(filename);
+  reader->Update();
+  m_Poly->DeepCopy(reader->GetOutput());
+  vtk2uLib_update();
+}
+
+vtkPolyData *vtkTriangleMesh::GetPolyData() const { return m_Poly; }
+
+void vtkTriangleMesh::Update() { uLib2vtk_update(); }
+
+} // namespace Vtk
+} // namespace uLib

src/Vtk/Math/vtkTriangleMesh.h

@@ -23,51 +23,47 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef VTKTRIANGLEMESH_H
 #define VTKTRIANGLEMESH_H
 
-
-#include "uLibVtkInterface.h"
 #include "Math/TriangleMesh.h"
+#include "Vtk/uLibVtkInterface.h"
 
 class vtkPolyData;
+class vtkActor;
 
 namespace uLib {
+namespace Vtk {
 
+class vtkTriangleMesh : public Puppet, public Polydata {
+  typedef TriangleMesh Content;
 
-class vtkTriangleMesh : public Abstract::uLibVtkPolydata {
-    typedef TriangleMesh Content;
 public:
-    vtkTriangleMesh(Content &content);
+  vtkTriangleMesh(Content &content);
-    ~vtkTriangleMesh();
+  ~vtkTriangleMesh();
 
-    void ReadFromFile(const char *filename);
+  void ReadFromFile(const char *filename);
 
-    void ReadFromXMLFile(const char *filename);
+  void ReadFromXMLFile(const char *filename);
 
-    void ReadFromObjFile(const char *filename);
+  void ReadFromObjFile(const char *filename);
 
-    void ReadFromStlFile(const char *filename);
+  void ReadFromStlFile(const char *filename);
 
-    virtual class vtkProp *GetProp();
+  virtual class vtkPolyData *GetPolyData() const;
 
-    virtual class vtkPolyData *GetPolyData() const;
+  void Update();
-
-    void Update();
 
 private:
-    void vtk2uLib_update();
+  void vtk2uLib_update();
-    void uLib2vtk_update();
+  void uLib2vtk_update();
 
-    TriangleMesh &m_content;
+  TriangleMesh &m_content;
-    vtkPolyData  *m_Poly;
+  vtkPolyData *m_Poly;
-    vtkActor     *m_Actor;
+  vtkActor *m_Actor;
 };
 
-
+} // namespace Vtk
-
+} // namespace uLib
-}
 
 #endif // VTKTRIANGLEMESH_H

src/Vtk/Math/vtkVoxImage.cpp

@@ -0,0 +1,286 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 <vtkImageExport.h>
+#include <vtkImageImport.h>
+#include <vtkSmartPointer.h>
+
+#include <vtkFloatArray.h>
+#include <vtkPointData.h>
+
+#include <vtkGenericDataObjectReader.h>
+#include <vtkImageShiftScale.h>
+
+#include <vtkColorTransferFunction.h>
+#include <vtkPiecewiseFunction.h>
+#include <vtkSmartVolumeMapper.h>
+#include <vtkVolumeProperty.h>
+
+#include <vtkActor.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkProperty.h>
+
+#include <Math/VoxImage.h>
+
+#include "Vtk/Math/vtkVoxImage.h"
+
+namespace uLib {
+namespace Vtk {
+
+void vtkVoxImage::GetContent() {
+  const int *dims = static_cast<const int *>(m_Content.GetDims().data());
+  m_Image->SetDimensions(dims);
+
+  float *spacing = m_Content.GetSpacing().data();
+  m_Image->SetSpacing(spacing[0], spacing[1], spacing[2]);
+
+  float *pos = m_Content.GetPosition().data();
+  m_Image->SetOrigin(pos[0], pos[1], pos[2]);
+
+  vtkFloatArray *array =
+      vtkFloatArray::SafeDownCast(m_Image->GetPointData()->GetScalars());
+  array->SetNumberOfTuples(m_Content.GetDims().prod());
+  Vector3i index(0, 0, 0);
+  int i = 0;
+  for (int zv = 0; zv < dims[2]; ++zv) {
+    for (int yv = 0; yv < dims[1]; ++yv) {
+      for (int xv = 0; xv < dims[0]; ++xv) {
+        index << xv, yv, zv;
+        array->SetValue(i++, m_Content.GetValue(index));
+      }
+    }
+  }
+  m_Image->GetPointData()->SetScalars(array);
+}
+
+void vtkVoxImage::SetContent() {
+  int *ext = m_Image->GetExtent();
+  int dims[3] = {ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, ext[5] - ext[4] + 1};
+  m_Content.SetDims(Vector3i(dims[0], dims[1], dims[2]));
+
+  double *spacing = m_Image->GetSpacing();
+  m_Content.SetSpacing(Vector3f(spacing[0], spacing[1], spacing[2]));
+
+  double *pos = m_Image->GetOrigin();
+  m_Content.SetPosition(Vector3f(pos[0], pos[1], pos[2]));
+
+  vtkFloatArray *array =
+      vtkFloatArray::SafeDownCast(m_Image->GetPointData()->GetScalars());
+  if (array) {
+    Vector3i index(0, 0, 0);
+    int i = 0;
+    for (int zv = 0; zv < dims[2]; ++zv) {
+      for (int yv = 0; yv < dims[1]; ++yv) {
+        for (int xv = 0; xv < dims[0]; ++xv) {
+          index << xv, yv, zv;
+          m_Content.SetValue(index, array->GetValue(i++));
+        }
+      }
+    }
+  } else {
+    std::cerr << "Error reading array Value Data\n";
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// VTK VOXIMAGE
+
+vtkVoxImage::vtkVoxImage(Content &content)
+    : m_Content(content), m_Actor(vtkVolume::New()),
+      m_Image(vtkImageData::New()), m_Outline(vtkCubeSource::New()),
+      m_Reader(NULL), m_Writer(NULL), writer_factor(1.E6) {
+  GetContent();
+  InstallPipe();
+}
+
+vtkVoxImage::~vtkVoxImage() {
+  m_Image->Delete();
+  m_Actor->Delete();
+  m_Outline->Delete();
+}
+
+vtkImageData *vtkVoxImage::GetImageData() {
+  GetContent();
+  return m_Image;
+}
+
+void vtkVoxImage::SaveToXMLFile(const char *fname) {
+  vtkSmartPointer<vtkXMLImageDataWriter> writer =
+      vtkSmartPointer<vtkXMLImageDataWriter>::New();
+  writer->SetFileName(fname);
+  GetContent();
+  vtkSmartPointer<vtkImageShiftScale> vtkscale =
+      vtkSmartPointer<vtkImageShiftScale>::New();
+
+#if VTK_MAJOR_VERSION <= 5
+  vtkscale->SetInputConnection(m_Image->GetProducerPort());
+#else
+  vtkscale->SetInputData(m_Image);
+#endif
+  vtkscale->SetScale(writer_factor);
+  vtkscale->Update();
+  writer->SetInputConnection(vtkscale->GetOutputPort());
+  writer->Update();
+  writer->Write();
+}
+
+void vtkVoxImage::ReadFromVKTFile(const char *fname) {
+  vtkSmartPointer<vtkGenericDataObjectReader> reader =
+      vtkSmartPointer<vtkGenericDataObjectReader>::New();
+  reader->SetFileName(fname);
+  reader->Update();
+  if (reader->IsFileStructuredPoints()) {
+    vtkSmartPointer<vtkImageShiftScale> vtkscale =
+        vtkSmartPointer<vtkImageShiftScale>::New();
+    vtkscale->SetInputConnection(reader->GetOutputPort());
+    vtkscale->SetScale(1 / writer_factor);
+    vtkscale->Update();
+
+    m_Image->DeepCopy(vtkscale->GetOutput());
+    SetContent();
+  } else {
+    std::cerr << "Error: file does not contain structured points\n";
+  }
+  m_Actor->Update();
+}
+
+void vtkVoxImage::ReadFromXMLFile(const char *fname) {
+  vtkSmartPointer<vtkXMLImageDataReader> reader =
+      vtkSmartPointer<vtkXMLImageDataReader>::New();
+  reader->SetFileName(fname);
+  reader->Update();
+  vtkSmartPointer<vtkImageShiftScale> vtkscale =
+      vtkSmartPointer<vtkImageShiftScale>::New();
+  vtkscale->SetInputConnection(reader->GetOutputPort());
+  vtkscale->SetScale(1 / writer_factor);
+  vtkscale->Update();
+
+  m_Image->DeepCopy(vtkscale->GetOutput());
+  SetContent();
+}
+
+void vtkVoxImage::setShadingPreset(int blendType) {
+  vtkSmartVolumeMapper *mapper = (vtkSmartVolumeMapper *)m_Actor->GetMapper();
+  vtkVolumeProperty *property = m_Actor->GetProperty();
+
+  static vtkColorTransferFunction *colorFun = vtkColorTransferFunction::New();
+  static vtkPiecewiseFunction *opacityFun = vtkPiecewiseFunction::New();
+
+  float window = 40 / writer_factor;
+  float level = 20 / writer_factor;
+
+  property->SetColor(colorFun);
+  property->SetScalarOpacity(opacityFun);
+  property->SetInterpolationTypeToLinear();
+
+  if (blendType != 6) {
+    colorFun->RemoveAllPoints();
+    opacityFun->RemoveAllPoints();
+  }
+
+  switch (blendType) {
+  case 0:
+    colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window,
+                           1.0);
+    mapper->SetBlendModeToMaximumIntensity();
+    break;
+  case 1:
+    colorFun->AddRGBSegment(level - 0.5 * window, 0.0, 0.0, 0.0,
+                            level + 0.5 * window, 1.0, 1.0, 1.0);
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window,
+                           1.0);
+    mapper->SetBlendModeToComposite();
+    property->ShadeOff();
+    break;
+  case 2:
+    colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
+    opacityFun->AddSegment(level - 0.5 * window, 0.0, level + 0.5 * window,
+                           1.0);
+    mapper->SetBlendModeToComposite();
+    property->ShadeOn();
+    break;
+  case 3:
+    colorFun->AddRGBPoint(-3024, 0, 0, 0, 0.5, 0.0);
+    colorFun->AddRGBPoint(-1000, .62, .36, .18, 0.5, 0.0);
+    colorFun->AddRGBPoint(-500, .88, .60, .29, 0.33, 0.45);
+    colorFun->AddRGBPoint(3071, .83, .66, 1, 0.5, 0.0);
+    opacityFun->AddPoint(-3024, 0, 0.5, 0.0);
+    opacityFun->AddPoint(-1000, 0, 0.5, 0.0);
+    opacityFun->AddPoint(-500, 1.0, 0.33, 0.45);
+    opacityFun->AddPoint(3071, 1.0, 0.5, 0.0);
+    mapper->SetBlendModeToComposite();
+    property->ShadeOn();
+    property->SetAmbient(0.1);
+    property->SetDiffuse(0.9);
+    property->SetSpecular(0.2);
+    property->SetSpecularPower(10.0);
+    property->SetScalarOpacityUnitDistance(0.8919);
+    break;
+  default:
+    vtkGenericWarningMacro("Unknown blend type.");
+    break;
+  }
+}
+
+void vtkVoxImage::Update() {
+  m_Actor->Update();
+  m_Outline->SetBounds(m_Image->GetBounds());
+  m_Outline->Update();
+}
+
+void vtkVoxImage::InstallPipe() {
+  vtkSmartPointer<vtkSmartVolumeMapper> mapper =
+      vtkSmartPointer<vtkSmartVolumeMapper>::New();
+#if VTK_MAJOR_VERSION <= 5
+  mapper->SetInputConnection(m_Image->GetProducerPort());
+#else
+  mapper->SetInputData(m_Image);
+#endif
+  mapper->Update();
+
+  m_Actor->SetMapper(mapper);
+  this->setShadingPreset(0);
+  mapper->Update();
+
+  m_Outline->SetBounds(m_Image->GetBounds());
+  vtkSmartPointer<vtkPolyDataMapper> mmapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
+  mmapper->SetInputConnection(m_Outline->GetOutputPort());
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+  actor->SetMapper(mmapper);
+  actor->GetProperty()->SetRepresentationToWireframe();
+  actor->GetProperty()->SetAmbient(0.7);
+
+  this->SetProp(m_Actor);
+}
+
+} // namespace Vtk
+} // namespace uLib

src/Vtk/Math/vtkVoxImage.h

@@ -23,73 +23,67 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_VTKVOXIMAGE_H
 #define U_VTKVOXIMAGE_H
 
-#include <vtkVolume.h>
+#include <vtkCubeSource.h>
 #include <vtkImageData.h>
+#include <vtkVolume.h>
 #include <vtkXMLImageDataReader.h>
 #include <vtkXMLImageDataWriter.h>
-#include <vtkCubeSource.h>
 
 #include <Math/VoxImage.h>
 
-#include "uLibVtkInterface.h"
+#include "Vtk/uLibVtkInterface.h"
-
 
 class vtkImageData;
 
 namespace uLib {
 namespace Vtk {
 
-class vtkVoxImage : public Puppet
+class vtkVoxImage : public Puppet {
-{
 public:
-    typedef Abstract::VoxImage Content;
+  typedef Abstract::VoxImage Content;
 
-    vtkVoxImage(Content &content);
+  vtkVoxImage(Content &content);
 
-    ~vtkVoxImage();
+  ~vtkVoxImage();
 
-    void GetContent();
+  void GetContent();
 
-    void SetContent();
+  void SetContent();
 
-    vtkImageData * GetImageData();
+  vtkImageData *GetImageData();
 
-    void SaveToXMLFile(const char *fname);
+  void SaveToXMLFile(const char *fname);
 
-    void ReadFromVKTFile(const char *fname);
+  void ReadFromVKTFile(const char *fname);
 
-    void ReadFromXMLFile(const char *fname);
+  void ReadFromXMLFile(const char *fname);
 
-    void setShadingPreset(int blendType = 2);
+  void setShadingPreset(int blendType = 2);
 
-    void Update();
+  void Update();
 
 protected:
-    void    InstallPipe();
+  void InstallPipe();
-    float   writer_factor;
+  float writer_factor;
 
 private:
-    vtkVolume             *m_Actor;
+  vtkVolume *m_Actor;
-    vtkImageData          *m_Image;
+  vtkImageData *m_Image;
-    vtkCubeSource         *m_Outline;
+  vtkCubeSource *m_Outline;
 
-    vtkXMLImageDataReader *m_Reader;
+  vtkXMLImageDataReader *m_Reader;
-    vtkXMLImageDataWriter *m_Writer;
+  vtkXMLImageDataWriter *m_Writer;
 
-    vtkVoxImage::Content  &m_Content;
+  vtkVoxImage::Content &m_Content;
-
-    float                  m_Window;
-    float                  m_Level;
 
+  float m_Window;
+  float m_Level;
 };
 
-} // vtk
+} // namespace Vtk
-} // uLib
+} // namespace uLib
-
 
 #endif // VTKVOXIMAGE_H

src/Vtk/testing/CMakeLists.txt

@@ -2,9 +2,6 @@
 set( TESTS
         vtkViewerTest
         vtkContainerBoxTest
-        vtkMuonScatter
-        vtkStructuredGridTest
-        vtkVoxRaytracerTest
         # vtkVoxImageTest
 #	vtkTriangleMeshTest
 )

src/Vtk/testing/vtkVoxImageTest.cpp

@@ -1,102 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 "Math/VoxImage.h"
-#include "Vtk/vtkVoxImage.h"
-#include "Vtk/uLibVtkViewer.h"
-
-#include "testing-prototype.h"
-
-using namespace uLib;
-
-struct TestVoxel {
-    Scalarf Value;
-    unsigned int Count;
-};
-
-int main()
-{
-    BEGIN_TESTING(Vtk Vox Image);
-
-    TestVoxel zero = {0,0};
-    TestVoxel nonzero = {5.5*1E-6,100};
-
-//    {   // SIMPLE TESTS //
-//        VoxImage<TestVoxel> img(Vector3i(10,10,10));
-//        img.SetSpacing(Vector3f(3,3,3));
-
-//        img.InitVoxels(zero);
-//        img[Vector3i(3,3,3)] = nonzero;
-
-//        Vtk::vtkVoxImage vtk_img(img);
-
-//        vtk_img.SaveToXMLFile("test.vti");
-//        vtk_img.setShadingPreset(0);
-
-//        //        vtk_img.ReadFromVKTFile("error.vtk");
-
-//        //        VoxImage<TestVoxel> img2 = img;
-
-//        //        Vtk::vtkVoxImage vtk_img2(img2);
-
-//        //        img2.ExportToVtk("error_saved.vtk",0);
-
-//        //        vtk_img2.SaveToXMLFile("error_saved.vti");
-
-//        Vtk::Viewer viewer;
-//        viewer.AddPuppet(vtk_img);
-//        viewer.Start();
-//    }
-
-    {   // SIMPLE TESTS //
-        VoxImage<TestVoxel> img(Vector3i(10,10,1));
-        img.SetSpacing(Vector3f(3,3,3));
-
-        img.InitVoxels(zero);
-        img[Vector3i(3,3,0)] = nonzero;
-
-        Vtk::vtkVoxImage vtk_img(img);
-
-        vtk_img.ReadFromVKTFile("test.vtk");
-        vtk_img.Update();
-
-        //        vtk_img.SaveToXMLFile("test.vti");
-        //        vtk_img.setShadingPreset(0);
-
-        //        Vtk::vtkVoxImage vtk_img2(img2);
-        //        img2.ExportToVtk("error_saved.vtk",0);
-        //        vtk_img2.SaveToXMLFile("error_saved.vti");
-
-        Vtk::Viewer viewer;
-        viewer.AddPuppet(vtk_img);
-        viewer.Start();
-    }
-
-
-    END_TESTING;
-}

src/Vtk/uLibVtkViewer.cpp

@@ -37,9 +37,29 @@
 #include <vtkTextProperty.h>
 #include <vtkAxesActor.h>
 #include <vtkCamera.h>
+#include <vtkInteractorStyleTrackballCamera.h>
+#include <vtkObjectFactory.h>
 
 #include "uLibVtkViewer.h"
 
+// Custom interactor style: disables spin/inertia so the scene only
+// rotates while the mouse is actively being moved with the button held.
+class vtkInteractorStyleNoSpin : public vtkInteractorStyleTrackballCamera
+{
+public:
+    static vtkInteractorStyleNoSpin *New();
+    vtkTypeMacro(vtkInteractorStyleNoSpin, vtkInteractorStyleTrackballCamera);
+
+    // Override: when the left button is released, immediately stop any
+    // ongoing motion (rotation/spin) so no momentum is carried over.
+    void OnLeftButtonUp() override
+    {
+        this->StopState();
+        vtkInteractorStyleTrackballCamera::OnLeftButtonUp();
+    }
+};
+vtkStandardNewMacro(vtkInteractorStyleNoSpin);
+
 namespace uLib {
 namespace Vtk {
 
@@ -75,6 +95,11 @@ void Viewer::InstallPipe()
             vtkSmartPointer<vtkRenderWindowInteractor>::New();
     renderWindowInteractor->SetRenderWindow(m_RenderWindow);
 
+    // Use a custom style with no spin/inertia
+    vtkSmartPointer<vtkInteractorStyleNoSpin> style =
+            vtkSmartPointer<vtkInteractorStyleNoSpin>::New();
+    renderWindowInteractor->SetInteractorStyle(style);
+
     // annotation //
     m_Annotation->GetTextProperty()->SetColor(1,1,1);
     m_Annotation->GetTextProperty()->SetFontFamilyToArial();

src/Vtk/vtkMuonEvent.cxx

@@ -1,170 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 "vtkMuonEvent.h"
-#include "Math/Dense.h"
-
-namespace uLib {
-
-///// CALLBACK /////////////////////////////////////////////////////////////////
-
-class vtkWidgetCallback : public vtkCommand
-{
-public:
-  static vtkWidgetCallback *New()
-    { return new vtkWidgetCallback; }
-  void SetParent(uLib::vtkMuonEvent *parent) { this->parent = parent; }
-  virtual void Execute(vtkObject *caller, unsigned long, void*)
-    {
-      vtkSmartPointer<vtkTransform> t =
-              vtkSmartPointer<vtkTransform>::New();
-      vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
-      widget->GetTransform(t);
-      //parent->SetTransform(t);
-      //std::cout << "event\n";
-  }
-private:
-  uLib::vtkMuonEvent *parent;
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-/////  VTK MUON EVENT  /////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-vtkMuonEvent::vtkMuonEvent(MuonEventData &content) :
-    m_Prop(vtkActor::New()),
-    m_PolyData(NULL),
-    m_Appender(vtkAppendPolyData::New()),
-    content(&content)
-{
-    InstallPipe();
-}
-
-vtkMuonEvent::vtkMuonEvent(const MuonEventData &content) :
-    m_Prop(vtkActor::New()),
-    m_PolyData(NULL),
-    m_Appender(vtkAppendPolyData::New()),
-    content(const_cast<MuonEventData *>(&content))
-{
-    InstallPipe();
-}
-
-
-vtkMuonEvent::~vtkMuonEvent()
-{
-    if (m_Prop) m_Prop->Delete();
-}
-
-vtkMuonEvent::Content &vtkMuonEvent::GetContent()
-{
-    return *content;
-}
-
-void vtkMuonEvent::PrintSelf(std::ostream &o) const
-{
-    o << "..:: MuonEvent ::..\n" \
-         "\t[in]  Origin    > " << content->LineIn().origin.transpose()    << "\n" <<
-         "\t[in]  Direction > " << content->LineIn().direction.transpose() << "\n" <<
-         "\t[out] Origin    > " << content->LineOut().origin.transpose()   << "\n" <<
-         "\t[out] Direction > " << content->LineOut().direction.transpose()<< "\n" <<
-         "\tMomentum        > " << content->GetMomentum() << "\n" <<
-         "...................\n";
-}
-
-vtkProp *vtkMuonEvent::GetProp()
-{
-    return m_Prop;
-}
-
-void vtkMuonEvent::InstallPipe()
-{
-
-
-    vtkAppendPolyData *appender = m_Appender;
-    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-
-    if(content) {
-        vtkSmartPointer<vtkLineSource> line_in = vtkSmartPointer<vtkLineSource>::New();
-        vtkSmartPointer<vtkLineSource> line_out = vtkSmartPointer<vtkLineSource>::New();
-
-        float distance = (content->LineIn().origin - content->LineOut().origin).norm() / 10;
-
-        HPoint3f pt;
-        pt = content->LineIn().origin;
-        line_in->SetPoint1(pt(0),pt(1),pt(2));
-        pt= content->LineIn().origin + content->LineIn().direction * distance;
-        line_in->SetPoint2(pt(0),pt(1),pt(2));
-        pt = content->LineOut().origin;
-        line_out->SetPoint1(pt(0),pt(1),pt(2));
-        pt = content->LineOut().origin + content->LineOut().direction * distance;
-        line_out->SetPoint2(pt(0),pt(1),pt(2));
-
-        appender->AddInputConnection(line_in->GetOutputPort());
-        appender->AddInputConnection(line_out->GetOutputPort());
-    }
-
-    appender->Update();
-    mapper->SetInputConnection(appender->GetOutputPort());
-    mapper->Update();
-    m_Prop->SetMapper(mapper);
-}
-
-vtkPolyData *vtkMuonEvent::GetPolyData() const
-{
-    return m_Appender->GetOutput();
-}
-
-void vtkMuonEvent::AddPocaPoint(HPoint3f poca)
-{
-    m_Poca = poca;
-    vtkSmartPointer<vtkSphereSource> sphere =
-            vtkSmartPointer<vtkSphereSource>::New();
-    float size = (content->LineIn().origin - content->LineOut().origin).head(3).norm();
-    size /= 100;
-    sphere->SetRadius(size);
-    sphere->SetCenter(poca(0),poca(1),poca(2));
-    sphere->Update();
-    m_Appender->AddInputConnection(sphere->GetOutputPort());
-    m_Appender->Update();
-}
-
-HPoint3f vtkMuonEvent::GetPocaPoint()
-{
-    return m_Poca;
-}
-
-
-
-
-
-}

src/Vtk/vtkMuonScatter.cxx

@@ -1,189 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 "vtkMuonScatter.h"
-#include "Math/Dense.h"
-
-namespace uLib {
-namespace Vtk {
-
-///// CALLBACK /////////////////////////////////////////////////////////////////
-
-//namespace {
-
-//class vtkWidgetCallback : public vtkCommand
-//{
-//public:
-//  static vtkWidgetCallback *New()
-//    { return new vtkWidgetCallback; }
-//  void SetParent(uLib::vtkMuonScatter *parent) { this->parent = parent; }
-//  virtual void Execute(vtkObject *caller, unsigned long, void*)
-//    {
-//      vtkSmartPointer<vtkTransform> t =
-//              vtkSmartPointer<vtkTransform>::New();
-//      vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
-//      widget->GetTransform(t);
-//      //parent->SetTransform(t);
-//      //std::cout << "Scatter\n";
-//  }
-//private:
-//  uLib::vtkMuonScatter *parent;
-//};
-
-//}
-
-
-////////////////////////////////////////////////////////////////////////////////
-/////  VTK MUON Scatter  /////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-vtkMuonScatter::vtkMuonScatter(MuonScatter &content) :
-    m_Content(&content),
-    m_LineIn(vtkLineSource::New()),
-    m_LineOut(vtkLineSource::New()),
-    m_PolyData(vtkPolyData::New()),
-    m_SpherePoca(NULL)
-{
-    InstallPipe();
-}
-
-vtkMuonScatter::vtkMuonScatter(const MuonScatter &content) :
-    m_Content(const_cast<MuonScatter *>(&content)),
-    m_LineIn(vtkLineSource::New()),
-    m_LineOut(vtkLineSource::New()),
-    m_PolyData(vtkPolyData::New()),
-    m_SpherePoca(NULL)
-{
-    InstallPipe();
-}
-
-
-vtkMuonScatter::~vtkMuonScatter()
-{
-    m_LineIn->Delete();
-    m_LineOut->Delete();
-    if(m_SpherePoca) m_SpherePoca->Delete();
-}
-
-vtkMuonScatter::Content &vtkMuonScatter::GetContent()
-{
-    return *m_Content;
-}
-
-void vtkMuonScatter::PrintSelf(std::ostream &o) const
-{}
-
-
-void vtkMuonScatter::InstallPipe()
-{
-    if(m_Content) {
-        vtkLineSource *line_in = m_LineIn;
-        vtkLineSource *line_out = m_LineOut;
-
-        float distance = (m_Content->LineIn().origin - m_Content->LineOut().origin).norm() / 10;
-
-        HPoint3f pt;
-        pt = m_Content->LineIn().origin;
-        line_in->SetPoint1(pt(0),pt(1),pt(2));
-        pt= m_Content->LineIn().origin + m_Content->LineIn().direction * distance;
-        line_in->SetPoint2(pt(0),pt(1),pt(2));
-        pt = m_Content->LineOut().origin;
-        line_out->SetPoint1(pt(0),pt(1),pt(2));
-        pt = m_Content->LineOut().origin + m_Content->LineOut().direction * distance;
-        line_out->SetPoint2(pt(0),pt(1),pt(2));
-    }
-
-    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(m_LineIn->GetOutputPort());
-    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
-    actor->SetMapper(mapper);
-    this->SetProp(actor);
-
-    mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(m_LineOut->GetOutputPort());
-    actor = vtkSmartPointer<vtkActor>::New();
-    actor->SetMapper(mapper);
-    this->SetProp(actor);
-}
-
-vtkPolyData *vtkMuonScatter::GetPolyData() const
-{
-    vtkSmartPointer<vtkAppendPolyData> append = vtkSmartPointer<vtkAppendPolyData>::New();
-    append->AddInputConnection(m_LineIn->GetOutputPort());
-    append->AddInputConnection(m_LineOut->GetOutputPort());
-    if(m_SpherePoca) append->AddInputConnection(m_SpherePoca->GetOutputPort());
-    append->Update();
-    m_PolyData->DeepCopy(append->GetOutput());
-    return m_PolyData;
-}
-
-void vtkMuonScatter::AddPocaPoint(HPoint3f poca)
-{
-    vtkSphereSource *sphere = vtkSphereSource::New();
-    float size = (m_Content->LineIn().origin - m_Content->LineOut().origin).head(3).norm();
-    size /= 100;
-    sphere->SetRadius(size);
-    sphere->SetCenter(poca(0),poca(1),poca(2));
-    sphere->Update();
-    m_SpherePoca = sphere;
-
-    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(m_SpherePoca->GetOutputPort());
-    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
-    actor->SetMapper(mapper);
-    this->SetProp(actor);
-}
-
-HPoint3f vtkMuonScatter::GetPocaPoint()
-{
-    double center[3];
-    if(m_SpherePoca) {
-        m_SpherePoca->GetCenter(center);
-        return HPoint3f(center[0],center[1],center[2]);
-    }
-    else {
-        return HPoint3f(0,0,0);
-    }
-}
-
-
-void vtkMuonScatter::ConnectInteractor(vtkRenderWindowInteractor *interactor)
-{
-    // TODO
-}
-
-
-
-
-} // vtk
-} // uLib

src/Vtk/vtkStructuredGrid.cpp

@@ -1,135 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 "Math/StructuredGrid.h"
-#include "Vtk/vtkStructuredGrid.h"
-
-namespace uLib {
-namespace Vtk {
-
-
-////////////////////////////////////////////////////////////////////////////////
-////// VTK STRUCTURED GRID /////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-
-vtkStructuredGrid::vtkStructuredGrid(Content &content) :
-    m_Content(&content),
-    m_Actor(vtkActor::New()),
-    m_Widget(vtkBoxWidget::New()),
-    m_Transform(vtkTransform::New())
-{
-    vtkSmartPointer<vtkWidgetCallback> callback =
-        vtkSmartPointer<vtkWidgetCallback>::New();
-    callback->SetGrid(this);
-    m_Widget->AddObserver(vtkCommand::InteractionEvent, callback);
-
-    this->InstallPipe();
-}
-
-vtkStructuredGrid::~vtkStructuredGrid()
-{
-    m_Actor->Delete();
-    m_Widget->Delete();
-    m_Transform->Delete();
-}
-
-
-void vtkStructuredGrid::SetTransform(vtkTransform *t)
-{
-    vtkMatrix4x4 *vmat = t->GetMatrix();
-    Matrix4f mat;
-    for(int i=0; i<4; ++i)
-        for(int j=0; j<4; ++j)
-            mat(i,j) = vmat->GetElement(i,j);
-    m_Content->SetMatrix(mat);
-
-    vtkSmartPointer<vtkMatrix4x4> vmat2 = vtkSmartPointer<vtkMatrix4x4>::New();
-    mat = m_Content->GetWorldMatrix();
-    for(int i=0; i<4; ++i)
-        for(int j=0; j<4; ++j)
-            vmat2->SetElement(i,j,mat(i,j));
-    m_Transform->SetMatrix(vmat2);
-    m_Transform->Update();
-    this->Update();
-}
-
-vtkBoxWidget *vtkStructuredGrid::GetWidget()
-{
-    return m_Widget;
-}
-
-void vtkStructuredGrid::Update()
-{
-    m_Actor->GetMapper()->Update();
-}
-
-void vtkStructuredGrid::InstallPipe()
-{
-    vtkSmartPointer<vtkCubeSource> cube =
-            vtkSmartPointer<vtkCubeSource>::New();
-    vtkSmartPointer<vtkTransformPolyDataFilter> filter =
-            vtkSmartPointer<vtkTransformPolyDataFilter>::New();
-
-    vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-    Matrix4f mat = m_Content->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);
-    filter->SetTransform(m_Transform);
-    filter->SetInputConnection(cube->GetOutputPort());
-
-    Vector3i dims = m_Content->GetDims();
-    cube->SetBounds(0,dims(0),0,dims(1),0,dims(2));
-    cube->Update();
-    filter->Update();
-
-    vtkSmartPointer<vtkPolyDataMapper> mapper =
-            vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(filter->GetOutputPort());
-
-    m_Actor->SetMapper(mapper);
-    m_Actor->GetProperty()->SetRepresentationToSurface();
-    m_Actor->GetProperty()->SetEdgeVisibility(true);
-    m_Actor->GetProperty()->SetOpacity(0.4);
-    m_Actor->GetProperty()->SetAmbient(0.7);
-    // set content transform to actor //
-    this->Update();
-    m_Widget->SetProp3D(m_Actor);
-
-    this->SetProp(m_Actor);
-}
-
-
-} // vtk
-} // uLib

src/Vtk/vtkTriangleMesh.cpp

@@ -1,206 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 <vtkSmartPointer.h>
-
-#include <vtkPolyDataReader.h>
-#include <vtkXMLPolyDataReader.h>
-#include <vtkOBJReader.h>
-#include <vtkSTLReader.h>
-
-#include <vtkPolyData.h>
-#include <vtkPoints.h>
-#include <vtkCellArray.h>
-#include <vtkActor.h>
-#include <vtkPolyDataMapper.h>
-
-#include "Vtk/vtkTriangleMesh.h"
-
-
-namespace uLib {
-
-
-void vtkTriangleMesh::vtk2uLib_update()
-{
-    // Assumes that Polys are Triangles !!! //
-    vtkIdType number_of_points = m_Poly->GetNumberOfPoints();
-    vtkIdType number_of_triangles = m_Poly->GetNumberOfPolys();
-
-    std::cout << "//////\n" <<
-                 "number of points = " << number_of_points << "\n" <<
-                 "muiber of polys  = " << number_of_triangles << "\n" <<
-                 "//////\n";
-
-
-
-
-
-    m_content.Points().resize(number_of_points);
-    for (int i=0; i<number_of_points; ++i)
-    {
-        double *point = m_Poly->GetPoint(i);
-        m_content.Points()[i](0) = point[0];
-        m_content.Points()[i](1) = point[1];
-        m_content.Points()[i](2) = point[2];
-//        std::cout << "pt" << i << " = " << m_content.Points()[i].transpose() << "\n";
-    }
-
-    m_content.Triangles().resize(number_of_triangles);
-    m_Poly->GetPolys()->InitTraversal();
-    vtkSmartPointer<vtkIdList> idList = vtkSmartPointer<vtkIdList>::New();
-    for (int i=0; i<number_of_triangles; ++i)
-    {
-        m_Poly->GetPolys()->GetNextCell(idList);
-        m_content.Triangles()[i](0) = idList->GetId(0);
-        m_content.Triangles()[i](1) = idList->GetId(1);
-        m_content.Triangles()[i](2) = idList->GetId(2);
-    }
-    m_Poly->Update();
-    m_Actor->GetMapper()->Update();
-}
-
-void vtkTriangleMesh::uLib2vtk_update()
-{
-    vtkIdType number_of_points = m_content.Points().size();
-    vtkIdType number_of_triangles = m_content.Triangles().size();
-
-    vtkSmartPointer<vtkPoints> points
-      = vtkSmartPointer<vtkPoints>::New();
-    points->SetNumberOfPoints(number_of_points);
-    for (vtkIdType i = 0; i < number_of_points; i++)
-      {
-      double x, y, z;
-      x = m_content.Points().at(i)(0);
-      y = m_content.Points().at(i)(1);
-      z = m_content.Points().at(i)(2);
-      points->SetPoint(i, x, y, z);
-      }
-
-    vtkSmartPointer<vtkCellArray> polys
-      = vtkSmartPointer<vtkCellArray>::New();
-    for (vtkIdType i = 0; i < number_of_triangles; i++)
-      {
-      vtkIdType a, b, c;
-      a = m_content.Triangles().at(i)(0);
-      b = m_content.Triangles().at(i)(1);
-      c = m_content.Triangles().at(i)(2);
-      polys->InsertNextCell(3);
-      polys->InsertCellPoint(a);
-      polys->InsertCellPoint(b);
-      polys->InsertCellPoint(c);
-      }
-
-    m_Poly->SetPoints(points);
-    m_Poly->SetPolys(polys);
-    m_Poly->Update();
-    m_Actor->GetMapper()->Update();
-}
-
-
-// -------------------------------------------------------------------------- //
-
-
-
-
-
-vtkTriangleMesh::vtkTriangleMesh(vtkTriangleMesh::Content &content) :
-    m_content(content),
-    m_Poly(vtkPolyData::New()),
-    m_Actor(vtkActor::New())
-{
-    vtkSmartPointer<vtkPolyDataMapper> mapper =
-            vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(m_Poly->GetProducerPort());
-    m_Actor->SetMapper(mapper);
-}
-
-vtkTriangleMesh::~vtkTriangleMesh()
-{
-    m_Poly->Delete();
-    m_Actor->Delete();
-}
-
-void vtkTriangleMesh::ReadFromFile(const char *filename)
-{
-    vtkSmartPointer<vtkPolyDataReader> reader =
-            vtkSmartPointer<vtkPolyDataReader>::New();
-    reader->SetFileName(filename);
-    reader->Update();
-    m_Poly->DeepCopy(reader->GetOutput());
-    vtk2uLib_update();
-}
-
-void vtkTriangleMesh::ReadFromXMLFile(const char *filename)
-{
-    vtkSmartPointer<vtkXMLPolyDataReader> reader =
-            vtkSmartPointer<vtkXMLPolyDataReader>::New();
-    reader->SetFileName(filename);
-    reader->Update();
-    m_Poly->DeepCopy(reader->GetOutput());
-    vtk2uLib_update();
-}
-
-void vtkTriangleMesh::ReadFromObjFile(const char *filename)
-{
-    vtkSmartPointer<vtkOBJReader> reader =
-            vtkSmartPointer<vtkOBJReader>::New();
-    reader->SetFileName(filename);
-    reader->Update();
-    m_Poly->DeepCopy(reader->GetOutput());
-    vtk2uLib_update();
-}
-
-void vtkTriangleMesh::ReadFromStlFile(const char *filename)
-{
-    vtkSmartPointer<vtkSTLReader> reader =
-            vtkSmartPointer<vtkSTLReader>::New();
-    reader->SetFileName(filename);
-    reader->Update();
-    m_Poly->DeepCopy(reader->GetOutput());
-    vtk2uLib_update();
-}
-
-vtkProp *vtkTriangleMesh::GetProp()
-{
-    return m_Actor;
-}
-
-vtkPolyData *vtkTriangleMesh::GetPolyData() const
-{
-    return m_Poly;
-}
-
-void vtkTriangleMesh::Update()
-{
-    uLib2vtk_update();
-}
-
-}

src/Vtk/vtkVoxImage.cpp

@@ -1,340 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// 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 <vtkSmartPointer.h>
-#include <vtkImageImport.h>
-#include <vtkImageExport.h>
-
-#include <vtkFloatArray.h>
-#include <vtkPointData.h>
-
-#include <vtkGenericDataObjectReader.h>
-#include <vtkImageShiftScale.h>
-
-#include <vtkSmartVolumeMapper.h>
-#include <vtkColorTransferFunction.h>
-#include <vtkPiecewiseFunction.h>
-#include <vtkVolumeProperty.h>
-
-#include <vtkActor.h>
-#include <vtkProperty.h>
-#include <vtkPolyDataMapper.h>
-
-
-#include <Math/VoxImage.h>
-
-#include "vtkVoxImage.h"
-
-
-namespace uLib {
-namespace Vtk {
-
-
-void vtkVoxImage::GetContent()
-{
-    // ULIB -> VTK //
-    const int *dims = static_cast<const int *>(m_Content.GetDims().data());
-    m_Image->SetDimensions(dims);
-
-    float *spacing = m_Content.GetSpacing().data();
-    m_Image->SetSpacing(spacing[0],spacing[1],spacing[2]);
-
-    // Warning .. TODO: Read complete Transform matrix //
-    float *pos = m_Content.GetPosition().data();
-    m_Image->SetOrigin(pos[0],pos[1],pos[2]);
-
-    vtkFloatArray *array = vtkFloatArray::SafeDownCast
-            (m_Image->GetPointData()->GetScalars());
-    array->SetNumberOfTuples(m_Content.GetDims().prod());
-    Vector3i index(0,0,0);
-    int i=0;
-    for (int zv = 0; zv < dims[2]; ++zv) {
-        for (int yv = 0; yv < dims[1]; ++yv) {
-            for (int xv = 0; xv < dims[0]; ++xv) {
-                index << xv,yv,zv;
-                array->SetValue(i++,m_Content.GetValue(index));
-            }
-        }
-    }
-    m_Image->GetPointData()->SetScalars(array);
-    //    m_Image->Update();
-}
-
-void vtkVoxImage::SetContent()
-{
-    // VTK -> ULIB //
-    int *ext = m_Image->GetExtent();
-    int dims[3] = { ext[1]-ext[0] + 1, ext[3]-ext[2] + 1, ext[5]-ext[4] + 1 };
-    m_Content.SetDims(Vector3i(dims[0],dims[1],dims[2]));
-
-    double *spacing = m_Image->GetSpacing();
-    m_Content.SetSpacing(Vector3f(spacing[0],spacing[1],spacing[2]));
-
-    // Warning .. TODO: Read complete Transform matrix //
-    double *pos = m_Image->GetOrigin();
-    m_Content.SetPosition(Vector3f(pos[0],pos[1],pos[2]));
-
-    vtkFloatArray *array = vtkFloatArray::SafeDownCast
-            (m_Image->GetPointData()->GetScalars());
-    if(array) {
-        Vector3i index(0,0,0);
-        int i=0;
-        for (int zv = 0; zv < dims[2]; ++zv) {
-            for (int yv = 0; yv < dims[1]; ++yv) {
-                for (int xv = 0; xv < dims[0]; ++xv) {
-                    index << xv,yv,zv;
-                    m_Content.SetValue(index,array->GetValue(i++));
-                }
-            }
-        }
-    }
-    else {
-        std::cerr << "Error reading array Value Data\n";
-    }
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// VTK VOXIMAGE
-
-vtkVoxImage::vtkVoxImage(Content &content) :
-    m_Content(content),
-    m_Actor(vtkVolume::New()),
-    m_Image(vtkImageData::New()),
-    m_Outline(vtkCubeSource::New()),
-    m_Reader(NULL),
-    m_Writer(NULL),
-    writer_factor(1.E6)
-{
-    GetContent();
-    InstallPipe();
-}
-
-vtkVoxImage::~vtkVoxImage()
-{
-    m_Image->Delete();
-    m_Actor->Delete();
-    m_Outline->Delete();
-}
-
-vtkImageData *vtkVoxImage::GetImageData()
-{
-    GetContent();
-    return m_Image;
-}
-
-void vtkVoxImage::SaveToXMLFile(const char *fname)
-{
-    vtkSmartPointer<vtkXMLImageDataWriter> writer =
-            vtkSmartPointer<vtkXMLImageDataWriter>::New();
-    writer->SetFileName(fname);
-    GetContent();
-    vtkSmartPointer<vtkImageShiftScale> vtkscale =
-            vtkSmartPointer<vtkImageShiftScale>::New();
-
-#   if VTK_MAJOR_VERSION <= 5
-    vtkscale->SetInputConnection(m_Image->GetProducerPort());
-#   else
-    vtkscale->SetInputData(m_Image);
-#   endif
-    vtkscale->SetScale(writer_factor);
-    vtkscale->Update();
-    writer->SetInputConnection(vtkscale->GetOutputPort());
-    writer->Update();
-    writer->Write();
-}
-
-void vtkVoxImage::ReadFromVKTFile(const char *fname)
-{
-    vtkSmartPointer<vtkGenericDataObjectReader> reader =
-            vtkSmartPointer<vtkGenericDataObjectReader>::New();
-    reader->SetFileName(fname);
-    reader->Update();
-    if(reader->IsFileStructuredPoints())
-    {
-        vtkSmartPointer<vtkImageShiftScale> vtkscale =
-                vtkSmartPointer<vtkImageShiftScale>::New();
-        vtkscale->SetInputConnection(reader->GetOutputPort());
-        vtkscale->SetScale(1/writer_factor);
-        vtkscale->Update();
-
-        m_Image->DeepCopy(vtkscale->GetOutput()); // FIX! (pipe connection)
-        SetContent();
-    }
-    else {
-        std::cerr << "Error: file does not contain structured points\n";
-    }
-    m_Actor->Update();
-}
-
-void vtkVoxImage::ReadFromXMLFile(const char *fname)
-{
-    vtkSmartPointer<vtkXMLImageDataReader> reader =
-            vtkSmartPointer<vtkXMLImageDataReader>::New();
-    reader->SetFileName(fname);
-    reader->Update();
-    vtkSmartPointer<vtkImageShiftScale> vtkscale =
-            vtkSmartPointer<vtkImageShiftScale>::New();
-    vtkscale->SetInputConnection(reader->GetOutputPort());
-    vtkscale->SetScale(1/writer_factor);
-    vtkscale->Update();
-
-    m_Image->DeepCopy(vtkscale->GetOutput());
-    SetContent();
-}
-
-
-void vtkVoxImage::setShadingPreset(int blendType)
-{
-    vtkSmartVolumeMapper *mapper =
-            (vtkSmartVolumeMapper *)m_Actor->GetMapper();
-    vtkVolumeProperty  *property = m_Actor->GetProperty();
-
-    static vtkColorTransferFunction *colorFun = vtkColorTransferFunction::New();
-    static vtkPiecewiseFunction *opacityFun = vtkPiecewiseFunction::New();
-
-    float window = 40 / writer_factor;
-    float level  = 20 / writer_factor;
-
-    property->SetColor(colorFun);
-    property->SetScalarOpacity(opacityFun);
-    property->SetInterpolationTypeToLinear();
-
-    if(blendType != 6) {
-        colorFun->RemoveAllPoints();
-        opacityFun->RemoveAllPoints();
-    }
-
-    switch (blendType) {
-        // MIP
-        // Create an opacity ramp from the window and level values.
-        // Color is white. Blending is MIP.
-    case 0:
-        colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
-        opacityFun->AddSegment(level - 0.5 * window, 0.0,
-                               level + 0.5 * window, 1.0);
-        mapper->SetBlendModeToMaximumIntensity();
-        break;
-
-        // CompositeRamp
-        // Create a ramp from the window and level values. Use compositing
-        // without shading. Color is a ramp from black to white.
-    case 1:
-        colorFun->AddRGBSegment(level - 0.5 * window, 0.0, 0.0, 0.0,
-                                level + 0.5 * window, 1.0, 1.0, 1.0);
-        opacityFun->AddSegment(level - 0.5 * window, 0.0,
-                               level + 0.5 * window, 1.0);
-        mapper->SetBlendModeToComposite();
-        property->ShadeOff();
-        break;
-
-        // CompositeShadeRamp
-        // Create a ramp from the window and level values. Use compositing
-        // with shading. Color is white.
-    case 2:
-        colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
-        opacityFun->AddSegment(level - 0.5 * window, 0.0,
-                               level + 0.5 * window, 1.0);
-        mapper->SetBlendModeToComposite();
-        property->ShadeOn();
-        break;
-
-        // CT_Skin
-        // Use compositing and functions set to highlight skin in CT data
-        // Not for use on RGB data
-    case 3:
-        colorFun->AddRGBPoint(-3024, 0, 0, 0, 0.5, 0.0);
-        colorFun->AddRGBPoint(-1000, .62, .36, .18, 0.5, 0.0);
-        colorFun->AddRGBPoint(-500, .88, .60, .29, 0.33, 0.45);
-        colorFun->AddRGBPoint(3071, .83, .66, 1, 0.5, 0.0);
-
-        opacityFun->AddPoint(-3024, 0, 0.5, 0.0);
-        opacityFun->AddPoint(-1000, 0, 0.5, 0.0);
-        opacityFun->AddPoint(-500, 1.0, 0.33, 0.45);
-        opacityFun->AddPoint(3071, 1.0, 0.5, 0.0);
-
-        mapper->SetBlendModeToComposite();
-        property->ShadeOn();
-        property->SetAmbient(0.1);
-        property->SetDiffuse(0.9);
-        property->SetSpecular(0.2);
-        property->SetSpecularPower(10.0);
-        property->SetScalarOpacityUnitDistance(0.8919);
-        break;
-
-
-    default:
-        vtkGenericWarningMacro("Unknown blend type.");
-        break;
-    }
-}
-
-void vtkVoxImage::Update() {
-    m_Actor->Update();
-    m_Outline->SetBounds(m_Image->GetBounds());
-    m_Outline->Update();
-}
-
-void vtkVoxImage::InstallPipe()
-{
-    vtkSmartPointer<vtkSmartVolumeMapper> mapper =
-            vtkSmartPointer<vtkSmartVolumeMapper>::New();
-#   if VTK_MAJOR_VERSION <= 5
-    mapper->SetInputConnection(m_Image->GetProducerPort());
-#   else
-    mapper->SetInputData(m_Image);
-#   endif
-    mapper->Update();
-
-    m_Actor->SetMapper(mapper);
-    this->setShadingPreset(0);
-    mapper->Update();
-
-    m_Outline->SetBounds(m_Image->GetBounds());
-    vtkSmartPointer<vtkPolyDataMapper> mmapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mmapper->SetInputConnection(m_Outline->GetOutputPort());
-    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
-    actor->SetMapper(mmapper);
-    actor->GetProperty()->SetRepresentationToWireframe();
-    actor->GetProperty()->SetAmbient(0.7);
-
-    //    this->SetProp(actor);
-    this->SetProp(m_Actor);
-}
-
-
-} // vtk
-} // uLib