Massive reorganization of CMake files

DOI added

.gitignore

@@ -0,0 +1,3 @@
+CMakeFiles/
+build/
+

CMake/uLibConfigHeader.cmake

@@ -16,12 +16,6 @@ set(BOOST_PP_VARIADICS ON)
 message(STATUS "PROJECT NAME = ${PROJECT_NAME}")
 message(STATUS "PACKAGE VERSION = ${PACKAGE_VERSION}")
 message(STATUS "PACKAGE NAME = ${PACKAGE_NAME}")
-execute_process(COMMAND "svnversion"
-                WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-                OUTPUT_VARIABLE SVN_REVISION
-                OUTPUT_STRIP_TRAILING_WHITESPACE )
-
-message(STATUS "SVN REVISION = ${SVN_REVISION}")
 
 CHECK_INCLUDE_FILES(inittypes.h HAVE_INITTYPES_H)
 CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H)

CMake/uLibFindDependencies.cmake

@@ -13,7 +13,7 @@ set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
 
-find_package(Boost 1.45.0 COMPONENTS serialization signals program_options REQUIRED)
+find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED)
 if(Boost_FOUND)
  set(HAVE_BOOST true)
 endif(Boost_FOUND)
@@ -75,36 +75,36 @@ endif(ULIB_USE_VTK)
 
 
 ## GEANT ##
-option(ULIB_USE_GEANT4 "Activate use of GEANT Integration" ON)
+#option(ULIB_USE_GEANT4 "Activate use of GEANT Integration" ON)
-message(STATUS "## GEANT 4 ##")
+#message(STATUS "## GEANT 4 ##")
-#include(FindGEANT4) # disabled using system finder
+##include(FindGEANT4) # disabled using system finder
-find_package(Geant4)
+#find_package(Geant4)
-set(GEANT4_FOUND Geant4_DIR)
+#set(GEANT4_FOUND Geant4_DIR)
-if(GEANT4_FOUND AND ULIB_USE_GEANT4)
+#if(GEANT4_FOUND AND ULIB_USE_GEANT4)
- message(STATUS "Looking for Geant4... - Geant4 found in ${Geant4_DIR}")
+# message(STATUS "Looking for Geant4... - Geant4 found in ${Geant4_DIR}")
- set(HAVE_GEANT4 true)
+# set(HAVE_GEANT4 true)
- include_directories(${Geant4_INCLUDE_DIRS})         # Add -I type paths
+# include_directories(${Geant4_INCLUDE_DIRS})         # Add -I type paths
- add_definitions(${Geant4_DEFINITIONS})              # Add -D type defs
+# add_definitions(${Geant4_DEFINITIONS})              # Add -D type defs
- debug_package(Geant4)
+# debug_package(Geant4)
-endif(GEANT4_FOUND AND ULIB_USE_GEANT4)
+#endif(GEANT4_FOUND AND ULIB_USE_GEANT4)
 
 ## QT4 ##
-option(ULIB_USE_QT4 "Activate use of Qt Framework" ON)
+#option(ULIB_USE_QT4 "Activate use of Qt Framework" ON)
-if(ULIB_USE_QT4)
+#if(ULIB_USE_QT4)
- message(STATUS "## QT4 ##")
+# message(STATUS "## QT4 ##")
- find_package(Qt4)
+# find_package(Qt4)
-# include_directories(${Qt4_INCLUDE_DIRS})
+## include_directories(${Qt4_INCLUDE_DIRS})
-# debug(Qt4_INCLUDE_DIRS)
+## debug(Qt4_INCLUDE_DIRS)
-endif(ULIB_USE_QT4)
+#endif(ULIB_USE_QT4)
 
 ## QT5 ##
-option(ULIB_USE_QT5 "Activate use of Qt Framework" ON)
+#option(ULIB_USE_QT5 "Activate use of Qt Framework" ON)
-if(ULIB_USE_QT5)
+#if(ULIB_USE_QT5)
- message(STATUS "## QT5 ##")
+# message(STATUS "## QT5 ##")
- find_package(Qt5Widgets)
+# find_package(Qt5Widgets)
-# include_directories(${Qt5_INCLUDE_DIRS})
+## include_directories(${Qt5_INCLUDE_DIRS})
-# debug(Qt5_INCLUDE_DIRS)
+## debug(Qt5_INCLUDE_DIRS)
-endif(ULIB_USE_QT5)
+#endif(ULIB_USE_QT5)
 
 ## READLINE ##
 message(STATUS "## READLINE ##")

CMake/uLibGenerateDoc.cmake

@@ -0,0 +1,97 @@
+find_package(Doxygen)
+
+set(doxydirlist "")
+foreach(modname ${ULIB_SELECTED_MODULES})
+    set(doxydirlist "${CMAKE_CURRENT_SOURCE_DIR}/src/${modname} ${doxydirlist}")
+endforeach(modname)
+
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg
+     "PROJECT_NAME=${CMAKE_PROJECT_NAME}-${PACKAGE_VERSION}\n"
+     "OUTPUT_DIRECTORY=${CMAKE_CURRENT_BINARY_DIR}\n"
+     "CREATE_SUBDIRS=NO\n"
+     "OUTPUT_LANGUAGE=English\n"
+     "BRIEF_MEMBER_DESC=YES\n"
+     "REPEAT_BRIEF=YES\n"
+     "ALWAYS_DETAILED_SEC=NO\n"
+     "INLINE_INHERITED_MEMB=NO\n"
+     "STRIP_FROM_INC_PATH=${CMAKE_CURRENT_SOURCE_DIR}/src\n"
+     "FULL_PATH_NAMES=YES\n"
+     "STRIP_FROM_PATH=${CMAKE_CURRENT_SOURCE_DIR}/src\n"
+     "SHORT_NAMES=NO\n"
+     "MULTILINE_CPP_IS_BRIEF=NO\n"
+     "INHERIT_DOCS=YES\n"
+     "DISTRIBUTE_GROUP_DOC=NO\n"
+     "OPTIMIZE_OUTPUT_FOR_C=YES\n"
+     "SUBGROUPING=YES\n"
+     "EXTRACT_ALL=YES\n"
+     "EXTRACT_PRIVATE=NO\n"
+     "EXTRACT_STATIC=NO\n"
+     "EXTRACT_LOCAL_CLASSES=YES\n"
+     "EXTRACT_LOCAL_METHODS=NO\n"
+     "HIDE_UNDOC_MEMBERS=NO\n"
+     "HIDE_UNDOC_CLASSES=NO\n"
+     "HIDE_FRIEND_COMPOUNDS=NO\n"
+     "HIDE_IN_BODY_DOCS=NO\n"
+     "INTERNAL_DOCS=NO\n"
+     "CASE_SENSE_NAMES=NO\n"
+     "HIDE_SCOPE_NAMES=NO\n"
+     "SHOW_INCLUDE_FILES=YES\n"
+     "INLINE_INFO=YES\n"
+     "SORT_MEMBER_DOCS=YES\n"
+     "SORT_BRIEF_DOCS=NO\n"
+     "SORT_BY_SCOPE_NAME=NO\n"
+     "GENERATE_TODOLIST=YES\n"
+     "GENERATE_TESTLIST=YES\n"
+     "GENERATE_BUGLIST=YES\n"
+     "GENERATE_DEPRECATEDLIST=YES\n"
+     "MAX_INITIALIZER_LINES=30\n"
+     "SHOW_USED_FILES=YES\n"
+     "QUIET=YES\n"
+     "WARNINGS=NO\n"
+     "WARN_IF_UNDOCUMENTED=YES\n"
+     "WARN_IF_DOC_ERROR=YES\n"
+     "WARN_FORMAT=\"$file:$line: $text\"\n"
+     "INPUT=${doxydirlist}\n"
+     "FILE_PATTERNS=*.h *.hpp\n"
+     "ENABLE_PREPROCESSING=YES\n"
+     "MACRO_EXPANSION=YES\n"
+     "RECURSIVE=YES\n"
+     "EXCLUDE_SYMLINKS=NO\n"
+     "FILTER_SOURCE_FILES=NO\n"
+     "SOURCE_BROWSER=NO\n"
+     "INLINE_SOURCES=NO\n"
+     "STRIP_CODE_COMMENTS=YES\n"
+     "REFERENCED_BY_RELATION=YES\n"
+     "REFERENCES_RELATION=YES\n"
+     "VERBATIM_HEADERS=YES\n"
+     "ALPHABETICAL_INDEX=YES\n"
+     "COLS_IN_ALPHA_INDEX=5\n"
+     "GENERATE_HTML=YES\n"
+     "HTML_OUTPUT=html\n"
+     "HTML_FILE_EXTENSION=.html\n"
+     "GENERATE_HTMLHELP=NO\n"
+     "BINARY_TOC=NO\n"
+     "TOC_EXPAND=NO\n"
+     "DISABLE_INDEX=NO\n"
+     "ENUM_VALUES_PER_LINE=4\n"
+     "GENERATE_TREEVIEW=YES\n"
+     "TREEVIEW_WIDTH=250\n"
+     "GENERATE_LATEX=NO\n"
+     "GENERATE_RTF=NO\n"
+     "GENERATE_MAN=NO\n"
+     "GENERATE_XML=NO\n"
+     "GENERATE_AUTOGEN_DEF=NO\n"
+     "GENERATE_PERLMOD=NO\n")
+
+option(NODOXYGEN "Disable the creation of the API documentation")
+if(NODOXYGEN OR (NOT DOXYGEN_FOUND))
+    message("Doxygen is disabled or not installed")
+else(NODOXYGEN OR (NOT DOXYGEN_FOUND))
+    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/html/index.html
+                       COMMAND doxygen ${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg)
+
+    add_custom_target(doxygen ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/html/index.html)
+
+    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
+            DESTINATION share/doc/${PACKAGE_NAME})
+endif(NODOXYGEN OR (NOT DOXYGEN_FOUND))

CMake/uLibTargetMacros.cmake

@@ -28,15 +28,17 @@ macro(uLib_add_shared_library name)
   set(ULIB_SHARED_LIBRARIES ${shared} PARENT_SCOPE)
   source_group("${project_name}\\${name}" FILES ${SOURCES})
   set_target_properties(${mname} PROPERTIES
-                      VERSION ${PROJECT_VERSION}
+                        VERSION ${PROJECT_VERSION}
-                      SOVERSION ${PROJECT_SOVERSION}
+                        SOVERSION ${PROJECT_SOVERSION}
-                      INTERFACE_LINK_LIBRARIES "${LIBRARIES}"
+#                       INTERFACE_LINK_LIBRARIES "${LIBRARIES}"
-                      LINK_INTERFACE_LIBRARIES "${LIBRARIES}"          ## <- ok for cmake from  2.12 ?
+#                       LINK_INTERFACE_LIBRARIES "${LIBRARIES}"          ## <- ok for cmake from  2.12 ?
-                      IMPORTED_LINK_INTERFACE_LIBRARIES "${LIBRARIES}" ## <- breaks cmake after 2.11 ?
+#                       IMPORTED_LINK_INTERFACE_LIBRARIES "${LIBRARIES}" ## <- breaks cmake after 2.11 ?
-#                      PUBLIC_HEADER ""
+#                       PUBLIC_HEADER ""
   )
   debug(LIBRARIES)
 
+  target_link_libraries(${mname} ${LIBRARIES})
+
   install(TARGETS ${mname}
          EXPORT "${PROJECT_NAME}Targets"
          RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
@@ -79,25 +81,17 @@ ENDMACRO(uLib_add_target)
 
 # TESTS and LIBRARIES must be defined
 macro(uLib_add_tests name)
- foreach(tn ${TESTS})
+    foreach(tn ${TESTS})
-  add_executable(${tn} EXCLUDE_FROM_ALL ${tn}.cpp)
+        add_executable(${tn} EXCLUDE_FROM_ALL ${tn}.cpp)
-  add_test(${tn} ${tn})
+        add_test(NAME ${tn} COMMAND ${tn})
 
-  # adds dependencies to all selected modules in uLib
+        target_link_libraries(${tn} ${LIBRARIES})
-  #  foreach(module ${ULIB_SELECTED_MODULES})
-  #   add_dependencies(${tn} ${project_name}${module})
-  #  endforeach(module)
 
-  # adds libraries dependencies
+    endforeach(tn)
-  foreach(library ${LIBRARIES})
-   target_link_libraries(${tn} ${library})
-  endforeach(library)
 
- endforeach(tn)
+    # custom target to compile all tests
-
+    add_custom_target(all-${name}-tests)
- # custom target to compile all tests
+    add_dependencies(all-${name}-tests ${TESTS})
- add_custom_target(all-${name}-tests)
- add_dependencies(all-${name}-tests ${TESTS})
 endmacro(uLib_add_tests name)
 
 

CMakeLists.txt

@@ -5,18 +5,13 @@
 
 cmake_minimum_required (VERSION 2.6)
 
-execute_process(COMMAND "clear")
-message("//////////////////////////////////////////////////////////////////////")
-message("/////////////////// CMAKE PJOJECT CONFIGURATION //////////////////////")
-message("//////////////////////////////////////////////////////////////////////")
-
 ## -------------------------------------------------------------------------- ##
 
 project(uLib)
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 2)
+set(PROJECT_VERSION_MINOR 3)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -31,207 +26,169 @@ set(PACKAGE_AUTHOR "Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>")
 
 set(ULIB_CMAKE_DIR "${PROJECT_SOURCE_DIR}/CMake")
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMake" ${CMAKE_MODULE_PATH})
-message(STATUS "Module path: ${CMAKE_MODULE_PATH}")
+message(STATUS "Project name = ${PROJECT_NAME}")
-
+message(STATUS "Package name = ${PACKAGE_NAME}")
-include(uLibMacros)
+message(STATUS "Package version = ${PACKAGE_VERSION}")
-include(uLibDebugMacro)
+message(STATUS "Module path = ${CMAKE_MODULE_PATH}")
-include(uLibTargetMacros)
-include(uLibGenerateRMake)
-
-
 
 ## GLOBALS ------------------------------------------------------------------ ##
 
-include(uLibCommon)
+set(PACKAGE_INSTALL_BIN_DIR ${CMAKE_INSTALL_PREFIX}/bin 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ") ## Add flags here ##
+    CACHE PATH "Installation directory for executables")
+set(PACKAGE_INSTALL_LIB_DIR ${CMAKE_INSTALL_PREFIX}/lib/
+    CACHE PATH "Installation directory for libraries")
+set(PACKAGE_INSTALL_INC_DIR ${CMAKE_INSTALL_PREFIX}/include/${PACKAGE_NAME}
+    CACHE PATH "Installation directory for headers")
+set(PACKAGE_INSTALL_DATA_DIR ${CMAKE_INSTALL_PREFIX}/share/${PACKAGE_NAME}
+    CACHE PATH "Installation directory for data files")
+set(PACKAGE_INSTALL_CMAKE_DIR ${CMAKE_INSTALL_PREFIX}/lib/cmake/${PACKAGE_NAME}
+    CACHE PATH "Installation directory for CMake files")
 
-enable_testing()
+set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    message(STATUS "Setting build type to 'Release' as none was specified.")
+    set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
+    set(CMAKE_EXE_LINKER_FLAGS "-Wl,--no-as-needed")
+    # Set the possible values of build type for cmake-gui
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY 
+               STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+set(CMAKE_CXX_WARNING_OPTION "" 
+    CACHE STRING "Warning level -WAll to verbose all warnings")
+set(CMAKE_VERBOSE_MAKEFILE FALSE
+    CACHE STRING "Verbose compile output switch")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x ${CMAKE_CXX_WARNING_OPTION}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON")
+
+#enable_testing()
 
 ## FIND PACKAGES ------------------------------------------------------------ ##
 
-include(uLibFindDependencies)
+set(Boost_USE_STATIC_LIBS OFF)
+set(Boost_USE_MULTITHREADED ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
+find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
 
+find_package(Eigen3 CONFIG REQUIRED)
+include(${EIGEN3_USE_FILE})
+
+find_package(ROOT CONFIG REQUIRED)
+include(${ROOT_USE_FILE})
+
+find_package(VTK CONFIG REQUIRED)
+include(${VTK_USE_FILE})
+
+set(CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_INCLUDES math.h)
+set(CMAKE_REQUIRED_LIBRARIES CMAKE_REQUIRED_LIBRARIES m)
 
 ## CONFIG ------------------------------------------------------------------- ##
 
-include(uLibConfigHeader)
+set(BOOST_PP_VARIADICS ON)
+
+include(CheckIncludeFiles)
+include(CheckFunctionExists)
+include(CheckSymbolExists)
+
+CHECK_INCLUDE_FILES(inittypes.h HAVE_INITTYPES_H)
+CHECK_INCLUDE_FILES(stdbool.h HAVE_STDBOOL_H)
+CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H)
+CHECK_INCLUDE_FILES(stdlib.h HAVE_STDLIB_H)
+CHECK_INCLUDE_FILES(dlfcn.h HAVE_DLFCN_H)
+CHECK_INCLUDE_FILES(malloc.h HAVE_MALLOC_H)
+CHECK_FUNCTION_EXISTS(malloc HAVE_MALLOC)
+CHECK_INCLUDE_FILES(memory.h HAVE_MEMORY_H)
+CHECK_INCLUDE_FILES(math.h HAVE_MATH_H)
+CHECK_FUNCTION_EXISTS(fsetround HAVE_FSETROUND)
+CHECK_FUNCTION_EXISTS(floor HAVE_FLOOR)
+CHECK_FUNCTION_EXISTS(pow HAVE_POW)
+CHECK_FUNCTION_EXISTS(sqrt HAVE_SQRT)
+CHECK_FUNCTION_EXISTS(strdup HAVE_STRDUP)
+CHECK_FUNCTION_EXISTS(strstr HAVE_STRSTR)
+CHECK_INCLUDE_FILES(strings.h HAVE_STRINGS_H)
+CHECK_INCLUDE_FILES(string.h HAVE_STRING_H)
+CHECK_INCLUDE_FILES(sys/stat.h HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILES(sys/types.h HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H)
+CHECK_INCLUDE_FILES(assert.h HAVE_ASSERT_H)
+
+configure_file("${PROJECT_SOURCE_DIR}/CMakeConfig.in.h"
+               "${PROJECT_BINARY_DIR}/config.h")
+
+install(FILES "${PROJECT_BINARY_DIR}/config.h"
+        DESTINATION ${PACKAGE_INSTALL_INC_DIR})
 
 ## ADD LIBRARIES SUBDIRECTORIES --------------------------------------------- ##
 
-## select modules ##
+include_directories(${PROJECT_BINARY_DIR})
-set(ULIB_SELECTED_MODULES
+include_directories(${SRC_DIR})
-      ltk
-      Core
-      Math
-      Detectors
-      Root
-)
 
 ## uLib_add_shared_library puts names there
 set(ULIB_SHARED_LIBRARIES)
+## select modules ##
+set(ULIB_SELECTED_MODULES)
 
-if(ULIB_USE_VTK)
+include_directories(${SRC_DIR}/Core)
- LIST(APPEND ULIB_SELECTED_MODULES Vtk)
+add_subdirectory(${SRC_DIR}/Core)
-endif(ULIB_USE_VTK)
 
-## this gets ulib modules into a variable ##
+include_directories(${SRC_DIR}/Math)
-function(uLib_modules result)
+add_subdirectory(${SRC_DIR}/Math)
- set(out)
- foreach(module ${ULIB_SELECTED_MODULES})
-  list(APPEND out ${PACKAGE_LIBPREFIX}${module})
- endforeach(module)
- set(${result} "${out}" PARENT_SCOPE)
-endfunction()
 
+include_directories(${SRC_DIR}/Detectors)
+add_subdirectory(${SRC_DIR}/Detectors)
 
-## ENTERING MODULES SUBDIRECTORIES ##
+include_directories(${SRC_DIR}/Root)
-message("/////////// SELECTED MODULES //////////////")
+add_subdirectory(${SRC_DIR}/Root)
-foreach(module ${ULIB_SELECTED_MODULES})
- message(STATUS "adding module: ${module}")
- set( uLib-module ${module})
- include_directories(${SRC_DIR}/${module})
- add_subdirectory(${SRC_DIR}/${module})
-endforeach(module)
 
-## SINGLE LIBRARY LINKING ## (work in progress ... )
+include_directories(${SRC_DIR}/Vtk)
-option(ULIB_SINGLELIBRARY "Link everything to a single library" OFF)
+add_subdirectory(${SRC_DIR}/Vtk)
-if(ULIB_SINGLELIBRARY) 
+
-# set(modgrp)
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")
-# foreach(module ${ULIB_SELECTED_MODULES})
+
-#  set(grpn srcgrp_${module})
+## Documentation and packages
-#  list(APPEND modgrp ${grpn})
+
-# endforeach(module)
+#include(uLibGenerateDoc)
-# add_library(${project_name} SHARED ${srcgrp_Core})
-endif(ULIB_SINGLELIBRARY)
 
 ## UTILITIES ##
-add_subdirectory("${SRC_DIR}/utils/make_recipe")
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")
-
-
-## PKG CONFIG compatible file ----------------------------------------------- ##
-
-set(PKGCONFIG_FILE_ENABLE OFF CACHE BOOL "enable pkg-config file")
-if(PKGCONFIG_FILE_ENABLE)
-message("/////////// PKG-CONFIG DISTILLER //////////////")
-set(PKGCONFIG_FILE_DESTDIR "/lib/pkgconfig/" CACHE PATH "destination path for pkg-config file")
-set(PKGCONFIG_LIBS)
-
-message(STATUS "[cflags] ${CMAKE_C_FLAGS}")
-message(STATUS "[cxxflags] ${CMAKE_CXX_FLAGS}")
-
-foreach(module ${ULIB_SHARED_LIBRARIES})
-set(PKGCONFIG_LIBS "${PKGCONFIG_LIBS} ${CMAKE_LINK_LIBRARY_FLAG}${module}")
-endforeach(module)
-message(STATUS "[libs] ${PKGCONFIG_LIBS}")
-
-set(PKGCONFIG_FLAGS)
-#add_custom_target(Dummy)
-
-# add the executable
-uLib_add_target(Dummy test.cpp)
-target_link_libraries(Dummy ${PACKAGE_LIBPREFIX}Core)
-target_link_libraries(Dummy ${Boost_SERIALIZATION_LIBRARY})
-target_link_libraries(Dummy ${Boost_SIGNALS_LIBRARY})
-target_link_libraries(Dummy ${Boost_PROGRAM_OPTIONS_LIBRARY})
-target_link_libraries(Dummy ${Geant4_LIBRARIES})
-target_link_libraries(Dummy ${ROOT_LIBRARIES})
-target_link_libraries(Dummy ${VTK_LIBRARIES})
-
-get_gcc_compile_flags(Dummy, gcc_flags_list)
-foreach(item ${gcc_flags_list})
- message(STATUS "[gcc cflags] ${item}")
- set(PKGCONFIG_FLAGS "${PKGCONFIG_FLAGS} ${item}")
-endforeach(item)
-message(STATUS "[includes] ${PKGCONFIG_FLAGS}")
-
-get_gcc_link_flags(Dummy, gcc_flags_list)
-foreach(item ${gcc_flags_list})
- message(STATUS "[gcc libs] ${item}")
-endforeach(item)
-
-configure_file(
-  "${PROJECT_SOURCE_DIR}/CMakePkgConfig.pc.in"
-  "${PROJECT_BINARY_DIR}/libmutom-${PACKAGE_VERSION}.pc"
-  )
-INSTALL_FILES(${PKGCONFIG_FILE_DESTDIR} FILES ${PROJECT_BINARY_DIR}/libmutom-${PACKAGE_VERSION}.pc)
-
-message("///////////////////////////////////////////")
-endif(PKGCONFIG_FILE_ENABLE)
-
-
-
 
 
 ## INSTALLS AND EXPORTS ----------------------------------------------------- ##
 
-#export(PACKAGE uLib)
+#export(PACKAGE ULIB)
-export(PACKAGE ULIB)
+#export(TARGETS ${ULIB_SHARED_LIBRARIES} ${ULIB_EXPORTED_TARGETS}
-export(TARGETS ${ULIB_SHARED_LIBRARIES} ${ULIB_EXPORTED_TARGETS}
+#       FILE "${PROJECT_BINARY_DIR}/uLibTargets.cmake"    )
-       FILE "${PROJECT_BINARY_DIR}/uLibTargets.cmake"    )
-#export(TARGETS ${ULIB_EXPORTED_TARGETS}
-#       FILE "${PROJECT_BINARY_DIR}/uLibExeTargets.cmake" )
 
 
 # Create the FooBarConfig.cmake and FooBarConfigVersion files
 file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
    "${PACKAGE_INSTALL_INC_DIR}")
+
 # ... for the build tree
-set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
+#set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
-configure_file(uLibConfig.cmake.in
+#configure_file(uLibConfig.cmake.in 
-  "${PROJECT_BINARY_DIR}/uLibConfig.cmake" @ONLY)
+#               "${PROJECT_BINARY_DIR}/uLibConfig.cmake" @ONLY)
+
 # ... for the install tree
 set(CONF_INCLUDE_DIRS "\${ULIB_CMAKE_DIR}/${REL_INCLUDE_DIR}")
 configure_file(uLibConfig.cmake.in
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake" @ONLY)
+               "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+               @ONLY)
+
 # ... for both
 configure_file(uLibConfigVersion.cmake.in
-  "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)
+               "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)
 
-# Install the FooBarConfig.cmake and FooBarConfigVersion.cmake
+install(FILES "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
-install(FILES
+              "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake"
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
-  "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake"
+        COMPONENT dev)
-  DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}" COMPONENT dev)
 
 # Install the export set for use with the install-tree
-install(EXPORT "${PROJECT_NAME}Targets" DESTINATION
+install(EXPORT "${PROJECT_NAME}Targets"
-  "${PACKAGE_INSTALL_CMAKE_DIR}" COMPONENT dev)
+        DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}"
-
+        COMPONENT dev)
-install(FILES ${PROJECT_SOURCE_DIR}/ulib.h DESTINATION ${PACKAGE_INSTALL_INC_DIR})
-
-
-
-## dummy main executable ---------------------------------------------------- ##
-
-message("Sara's debug....")
-message(${ROOT_LIBRARIES})
-
-# add the executable
-add_executable(Coretest test.cpp)
-target_link_libraries(Coretest ${PACKAGE_LIBPREFIX}Core)
-#target_link_libraries(Coretest ${Boost_SERIALIZATION_LIBRARY})
-#target_link_libraries(Coretest ${Boost_SIGNALS_LIBRARY})
-#target_link_libraries(Coretest ${Boost_PROGRAM_OPTIONS_LIBRARY})
-#target_link_libraries(Coretest ${Geant4_LIBRARIES})
-target_link_libraries(Coretest ${ROOT_LIBRARIES})
-target_link_libraries(Coretest ${VTK_LIBRARIES})
-
-#message( "---------------------------------------------------------------------" )
-#execute_process(COMMAND
-#                "ls"
-##                "cmake --find-package -DNAME=uLib -DLANGUAGE=C -DCOMPILER_ID=GNU -DMODE=COMPILE"
-#                )
-#message( "---------------------------------------------------------------------" )
-
-## -------------------------------------------------------------------------- ##
-
-
-# TODO clean also subdirectories
-add_custom_target(clean-cmake-files
-   COMMAND ${CMAKE_COMMAND} -P ${ULIB_CMAKE_DIR}/clean-all.cmake
-)
-
-
-
-
 

Jenkinsfile

@@ -0,0 +1,35 @@
+pipeline {
+
+    agent {
+        docker {
+            image 'infnpd/cmt-environment:1.1-centos7'
+            args '-u 0:0'
+            label 'DOCKER'
+        }
+    }
+
+    environment {
+        NEXUS_PD_CREDS = credentials('jenkins-nexus-pd-creds')
+        NEXUS_PD_URL = 'https://cld-smact-02.pd.infn.it/artifacts/repository/muotom/devel/centos7/x86_64/'
+    }
+
+    stages {
+
+        stage('Build') {
+
+            steps {
+                sh "mkdir build && cd build && cmake -DNODOXYGEN=ON .. && make rpm"
+            }
+
+        }
+        stage('Deploy') {
+
+            steps {
+                sh "find . -name '*.x86_64.rpm' curl -v -k --user '${NEXUS_PD_CREDS_USR}:${NEXUS_PD_CREDS_PSW}' --upload-file '{}' ${NEXUS_PD_URL} ';'"
+            }
+
+        }
+
+    }
+
+}

README.md

@@ -0,0 +1,9 @@
+# uLib
+
+[![DOI](https://zenodo.org/badge/36926725.svg)](https://zenodo.org/badge/latestdoi/36926725)
+
+base toolkit library
+
+CMT Cosmic Muon Tomography reconstruction, analysis and imaging software
+Developed by University of Padova and INFN Sezione di Padova  Italy
+

src/Core/CMakeLists.txt

@@ -1,46 +1,27 @@
 
-set(HEADERS
+set(HEADERS Options.h
-                                Archives.h
+            StaticInterface.h)
-                                Array.h
+
-                                Collection.h
+set(SOURCES Options.cpp)
-                                Debug.h
+
-                                Export.h
+set(LIBRARIES ${Boost_PROGRAM_OPTIONS_LIBRARY})
-                                Function.h
+
-                                Macros.h
+set(libname ${PACKAGE_LIBPREFIX}Core)
-                                Mpl.h
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
-                                Object.h
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Core PARENT_SCOPE)
-                                ObjectProps.h
+
-                                Options.h
+add_library(${libname} SHARED ${SOURCES})
-                                Serializable.h
+set_target_properties(${libname} PROPERTIES
-                                Signal.h
+                      VERSION ${PROJECT_VERSION}
-                                Singleton.h
+                      SOVERSION ${PROJECT_SOVERSION})
-                                SmartPointer.h
+target_link_libraries(${libname} ${LIBRARIES})
-                                StaticInterface.h
+
-                                StringReader.h
+install(TARGETS ${libname}
-                                Types.h
+        EXPORT "${PROJECT_NAME}Targets"
-                                Uuid.h
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-                                Vector.h
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
-                                CommaInitializer.h
+
-                                Timer.h
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Core)
-)
 
-SET(SOURCES
-                Archives.cpp
-                Object.cpp
-                Options.cpp
-                Serializable.cpp
-                Signal.cpp
-                Uuid.cpp
-)
 
-set(LIBRARIES
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-)
 
-uLib_add_shared_library(${uLib-module})
-add_subdirectory(testing)

src/Core/Debug.h

@@ -29,12 +29,11 @@
 #define U_CORE_DEBUG_H
 
 
-
+#include <vector>
-#include "ltk/ltkdebug.h"
 #include "Macros.h"
 #include "Types.h"
 #include "Mpl.h"
-#include "Vector.h"
+#include "SmartPointer.h"
 
 #include <boost/any.hpp>
 #include <TObject.h>
@@ -128,8 +127,8 @@ public:
     }
 
 private:
-    Vector<DItem>     m_v;
+    std::vector<DItem>     m_v;
-    Vector<Adapter>   m_a;
+    std::vector<Adapter>   m_a;
 };
 
 

src/Core/StringReader.h

@@ -31,7 +31,6 @@
 #include <istream>
 #include <algorithm>
 
-#include "Core/Vector.h"
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 

src/Core/Types.h

@@ -33,7 +33,7 @@
 
 #include <boost/preprocessor.hpp>
 
-#include <ltk/ltktypes.h>
+//#include <ltk/ltktypes.h>
 
 #include "Core/Macros.h"
 #include "Core/Mpl.h"
@@ -161,12 +161,21 @@ struct TypeIntrospection {
 #define CONSTEXPR BOOST_CONSTEXPR
 
 
-typedef ltk::Real_t      Real_t;
+//typedef ltk::Real_t      Real_t;
-typedef ltk::Id_t        Id_t;
+#ifndef LTK_DOUBLE_PRECISION
-//typedef ltk::Size_t      Size_t;
+typedef float      Real_t;
-typedef ltk::Pointer_t   Pointer_t;
+#else
+typedef double     Real_t;
+#endif
+//typedef ltk::Id_t        Id_t;
+typedef id_t       Id_t;
+////typedef ltk::Size_t      Size_t;
+//typedef ltk::Pointer_t   Pointer_t;
+typedef void *     Pointer_t;
 typedef bool             Bool_t;      //Boolean (0=false, 1=true) (bool)
 
+
+
 //--- bit manipulation ---------------------------------------------------------
 #ifndef BIT
 #define BIT(n)       (1ULL << (n))

src/Core/Uuid.h

@@ -29,6 +29,7 @@
 #define U_CORE_UUID_H
 
 #include <iostream>
+#include <vector>
 
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/name_generator.hpp>
@@ -36,7 +37,6 @@
 #include <boost/uuid/uuid_io.hpp>
 
 #include "Core/Mpl.h"
-#include "Core/Vector.h"
 #include "Core/Object.h"
 
 
@@ -127,7 +127,7 @@ public:
 
 private:
     IDGen_t gen;
-    Vector<RegisterEntry> m_registry;
+    std::vector<RegisterEntry> m_registry;
 
 };
 

src/Core/testing/SerializeTest.cpp

@@ -31,7 +31,6 @@
 
 #include "Core/Object.h"
 #include "Core/Archives.h"
-#include "ParticlePhysics/MuonTomography/MuonScatter.h"
 
 #include "testing-prototype.h"
 
@@ -189,48 +188,12 @@ int testing_hrt_class() {
 
 
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// MUON SCATTER EXAMPLE //
-
-int testing_mu()
-{     
-     std::stringstream ss;
-
-     MuonScatter mu;
-     mu.SetMomentumIn(555);
-     mu.SetMomentumOut(2368);
-     {
-         std::ofstream file("test.txt");
-         file << mu;
-     }
-
-     mu.SetMomentumIn(0);
-     mu.SetMomentumOut(0);
-     {
-         std::ifstream file("test.txt");
-         file >> mu;
-     }
-
-     std::cout << mu << "\n";
-
-
-}
-
-
-
-
-
-
 int main() {
     BEGIN_TESTING(Serialize Test);
 
     TEST1( test_V3f() );
     TEST1( testing_xml_class() );
     //    testing_hrt_class(); ///// << ERRORE in HRT with properties
-    TEST1( testing_mu() );
 
     END_TESTING;
 }

src/Detectors/CMakeLists.txt

@@ -1,38 +1,6 @@
-# HEADERS
+set(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
-set(HEADERS
-                                DetectorChamber.h
-                                ExperimentFitEvent.h
-                                GeantEvent.h
-                                HitMC.h
-                                MuonScatter.h
-                                MuonEvent.h
-                                MuonError.h
-                                ChamberHitEvent.h
-                                Hit.h
-                                LinearFit.h
-                                Solid.h
-                                Matter.h
-                                Scene.h
-)
 
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
 
-# SOURCES
+install(FILES ${HEADERS}
-set(SOURCES
+        DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Detectors)
-                Solid.cpp
-                Scene.cpp
-)
-
-set(LIBRARIES
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${Eigen_LIBRARY}
-       ${Geant4_LIBRARIES}
-       ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-       ${PACKAGE_LIBPREFIX}Detectors
-)
-
-uLib_add_shared_library(${uLib-module})
-add_subdirectory(testing)

src/Detectors/HitMC.h

@@ -28,7 +28,6 @@
 #ifndef U_HITMC_H
 #define U_HITMC_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 #include "Hit.h"
 
@@ -43,10 +42,10 @@ public:
         DeltaRay
     };
 
-    uLibConstRefMacro(Position,HPoint3f)
+    inline const HPoint3f & Position() const { return this->m_Position; }
-    uLibGetMacro(Type, enum Type)
+    inline enum Type GetType() const { return this->m_Type; }
 
-private:
+protected:
     HPoint3f  m_Position;
     enum Type m_Type;
 };
@@ -54,8 +53,8 @@ private:
 
 class HitMC : public HitMCData {
 public:
-    uLibRefMacro(Position,HPoint3f)
+    inline HPoint3f & Position() { return this->m_Position; }
-    uLibSetMacro(Type, enum Type)
+    inline void SetType(enum Type name) { this->m_Type = name; }
 };
 
 

src/Detectors/LinearFit.h

@@ -28,7 +28,6 @@
 #ifndef U_LINEARFIT_H
 #define U_LINEARFIT_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 #include "ChamberDetector.h"
 
@@ -37,32 +36,31 @@ namespace uLib {
 
 class LinearFitData {
 public:
-    uLibConstRefMacro(Position,Vector2f)
+    inline const Vector2f & Position() const { return this->m_Position; }
-    uLibConstRefMacro(Slope,Vector2f)
+    inline const Vector2f & Slope() const { return this->m_Slope; }
-    uLibConstRefMacro(PositionError,Vector2f)
+    inline const Vector2f & PositionError() const { return this->m_PositionError; }
-    uLibConstRefMacro(SlopeError,Vector2f)
+    inline const Vector2f & SlopeError() const { return this->m_SlopeError; }
-    uLibGetMacro(HitsNumber,int)
+    inline int GetHitsNumber() const { return this->m_HitsNumber; }
-    uLibGetMacro(Idv,ChamberDetector::ID)
+    inline ChamberDetector::ID GetIdv() const { return this->m_Idv; }
 
-private:
+protected:
-        friend class LinearFit;
+    Vector2f            m_Position;
-    Vector2f m_Position;
+    Vector2f            m_Slope;
-    Vector2f m_Slope;
+    Vector2f            m_PositionError;
-    Vector2f m_PositionError;
+    Vector2f            m_SlopeError;
-    Vector2f m_SlopeError;
+    int                 m_HitsNumber;
-    int      m_HitsNumber;
     DetectorChamber::ID m_Idv;
 };
 
 
 class LinearFit : public LinearFitData {
 public:
-    uLibRefMacro(Position,Vector2f)
+    inline Vector2f & Position() { return this->m_Position; }
-    uLibRefMacro(Slope,Vector2f)
+    inline Vector2f & Slope() { return this->m_Slope; }
-    uLibRefMacro(PositionError,Vector2f)
+    inline Vector2f & PositionError() { return this->m_PositionError; }
-    uLibRefMacro(SlopeError,Vector2f)
+    inline Vector2f & SlopeError() { return this->m_SlopeError; }
-    uLibSetMacro(HitsNumber,int)
+    inline void SetHitsNumber(int name) { this->m_HitsNumber = name; }
-    uLibSetMacro(Idv,ChamberDetector::ID)
+    inline void SetIdv(ChamberDetector::ID name) { this->m_Idv = name; }
 };
 
 

src/Detectors/MuonError.h

@@ -28,18 +28,16 @@
 #ifndef U_MUONERROR_H
 #define U_MUONERROR_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
 
 class MuonErrorData {
-    friend class MuonError;
 public:
-    uLibConstRefMacro(Theta,Scalarf)
+    inline const Scalarf & Theta() const { return this->m_Theta; }
-    uLibConstRefMacro(Phi,Scalarf)
+    inline const Scalarf & Phi() const { return this->m_Phi; }
-private:
+protected:
     Scalarf m_Theta;
     Scalarf m_Phi;
 };
@@ -47,8 +45,8 @@ private:
 
 class MuonError  : public MuonErrorData {
 public:
-    uLibRefMacro(Theta,Scalarf)
+    inline Scalarf & Theta() { return this->m_Theta; }
-    uLibRefMacro(Phi,Scalarf)
+    inline Scalarf & Phi() { return this->m_Phi; }
 };
 
 

src/Detectors/MuonEvent.h

@@ -28,20 +28,18 @@
 #ifndef U_MUONEVENT_H
 #define U_MUONEVENT_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
 
 class MuonEventData {
-    friend class MuonEvent;
 public:
-    uLibConstRefMacro(LineIn,HLine3f)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
-    uLibConstRefMacro(LineOut,HLine3f)
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
-    uLibGetMacro(Momentum,Scalarf)
+    inline Scalarf GetMomentum() const { return this->m_Momentum; }
 
-private:
+protected:
     HLine3f  m_LineIn;
     HLine3f  m_LineOut;
     Scalarf  m_Momentum;
@@ -50,9 +48,9 @@ private:
 
 class MuonEvent  : public MuonEventData {
 public:
-    uLibRefMacro(LineIn,HLine3f)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
-    uLibRefMacro(LineOut,HLine3f)
+    inline HLine3f & LineOut() { return this->m_LineOut; }
-    uLibRefMacro(Momentum,Scalarf)
+    inline Scalarf & Momentum() { return this->m_Momentum; }
 
 };
 

src/Detectors/MuonScatter.h

@@ -29,7 +29,6 @@
 #ifndef U_MUONSCATTER_H
 #define U_MUONSCATTER_H
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 namespace uLib {
@@ -37,20 +36,21 @@ namespace uLib {
 
 class MuonScatter {
 public:
-    uLibConstRefMacro(LineIn,HLine3f)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
-    uLibConstRefMacro(ErrorIn,HError3f)
+    inline const HError3f & ErrorIn() const { return this->m_ErrorIn; }
-    uLibConstRefMacro(LineOut,HLine3f)
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
-    uLibConstRefMacro(ErrorOut,HError3f)
+    inline const HError3f & ErrorOut() const { return this->m_ErrorOut; }
 
-    uLibRefMacro(LineIn,HLine3f)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
-    uLibRefMacro(ErrorIn,HError3f)
+    inline HError3f & ErrorIn() { return this->m_ErrorIn; }
-    uLibRefMacro(LineOut,HLine3f)
+    inline HLine3f & LineOut() { return this->m_LineOut; }
-    uLibRefMacro(ErrorOut,HError3f)
+    inline HError3f & ErrorOut() { return this->m_ErrorOut; }
-    uLibSetMacro(Momentum,Scalarf)
-    uLibSetMacro(MomentumPrime,Scalarf)
 
-    uLibGetMacro(Momentum,Scalarf)
+    inline void SetMomentum(Scalarf name) { this->m_Momentum = name; }
-    uLibGetMacro(MomentumPrime,Scalarf)
+    inline void SetMomentumPrime(Scalarf name) { this->m_MomentumPrime = name; }
+
+    inline Scalarf GetMomentum() const { return this->m_Momentum; }
+    inline Scalarf GetMomentumPrime() const { return this->m_MomentumPrime; }
 
 protected:
     HLine3f  m_LineIn;

src/Math/Accumulator.h

@@ -28,7 +28,8 @@
 #ifndef U_DATABINNING_H
 #define U_DATABINNING_H
 
-#include "Core/Vector.h"
+#include <vector>
+
 #include "Dense.h"
 
 
@@ -69,7 +70,7 @@ public:
     void AddPass() { m_Means.push_back( Tmean(0,0) ); }
 
 private:
-    Vector< Tmean > m_Means;
+    std::vector< Tmean > m_Means;
 };
 
 

src/Math/BitCode.h

@@ -29,13 +29,11 @@
 
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
-//#include <Core/CommaInitializer.h>
-#include <Math/Dense.h>
-
-#include <Core/Mpl.h>
 #include <boost/mpl/vector_c.hpp>
 #include <boost/mpl/set_c.hpp>
 
+#include <Math/Dense.h>
+
 namespace uLib {
 
 
@@ -237,9 +235,9 @@ public:
 //        std::cout << boost::mpl::at_c< BitSet,1 >::type::value << "\n";
     }
 
-    int Get(unsigned short field) const {
+//    int Get(unsigned short field) const {
-        return boost::mpl::at_c< BitSet, field >::type::value;
+//        return boost::mpl::at_c< BitSet, field >::type::value;
-    }
+//    }
 };
 
 

src/Math/CMakeLists.txt

@@ -1,50 +1,53 @@
+set(HEADERS ContainerBox.h
+            Dense.h
+            Geometry.h
+            Transform.h
+            StructuredData.h
+            StructuredGrid.h
+            VoxImage.h
+            VoxRaytracer.h
+            Utils.h
+            VoxImageFilter.h
+            VoxImageFilter.hpp
+            VoxImageFilterLinear.hpp
+            VoxImageFilterMedian.hpp
+            VoxImageFilterABTrim.hpp
+            VoxImageFilterBilateral.hpp
+            VoxImageFilterThreshold.hpp
+            VoxImageFilter2ndStat.hpp
+            VoxImageFilterCustom.hpp
+            Accumulator.h
+            TriangleMesh.h
+            BitCode.h
+            Structured2DGrid.h
+            Structured4DGrid.h)
 
-# HEADERS
+set(SOURCES VoxRaytracer.cpp
-set(HEADERS
+            StructuredData.cpp
-                                ContainerBox.h
+            StructuredGrid.cpp
-                                Dense.h
+            VoxImage.cpp
-                                Geometry.h
+            TriangleMesh.cpp
-                                Transform.h
+            Dense.cpp
-                                StructuredData.h
+            Structured2DGrid.cpp
-                                StructuredGrid.h
+            Structured4DGrid.cpp)
-                                VoxImage.h
-                                VoxRaytracer.h
-                                Utils.h
-                                VoxImageFilter.h
-                                VoxImageFilter.hpp
-                                VoxImageFilterLinear.hpp
-                                VoxImageFilterMedian.hpp
-                                VoxImageFilterABTrim.hpp
-                                VoxImageFilterBilateral.hpp
-                                VoxImageFilterThreshold.hpp
-                                VoxImageFilter2ndStat.hpp
-                                VoxImageFilterCustom.hpp
-                                Accumulator.h
-                                TriangleMesh.h
-                                BitCode.h
-)
 
+set(LIBRARIES ${Eigen_LIBRARY}
+              ${ROOT_LIBRARIES})
 
-# SOURCES
+set(libname ${PACKAGE_LIBPREFIX}Math)
-set(SOURCES
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
-                VoxRaytracer.cpp
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Math PARENT_SCOPE)
-                StructuredData.cpp
-                StructuredGrid.cpp
-                VoxImage.cpp
-                TriangleMesh.cpp
-                Dense.cpp
-)
 
-set(LIBRARIES
+add_library(${libname} SHARED ${SOURCES})
-       ${Boost_SERIALIZATION_LIBRARY}
+set_target_properties(${libname} PROPERTIES
-       ${Boost_SIGNALS_LIBRARY}
+                      VERSION ${PROJECT_VERSION}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+                      SOVERSION ${PROJECT_SOVERSION})
-       ${Eigen_LIBRARY}
+target_link_libraries(${libname} ${LIBRARIES})
-       ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-)
 
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Math)
 
-uLib_add_shared_library(${uLib-module})
-add_subdirectory(testing)

src/Math/Dense.cpp

@@ -27,8 +27,8 @@
 
 
 #include "Dense.h"
-#include "Core/Archives.h"
 
+#ifdef ULIB_SERIALIZATION_ON
 ULIB_SERIALIZE(uLib::HPoint3f) {
     ar & boost::serialization::make_nvp(NULL,boost::serialization::base_object<uLib::HPoint3f::BaseClass,uLib::HPoint3f>(ob));
 }
@@ -48,5 +48,5 @@ ULIB_SERIALIZE(uLib::HError3f) {
     ar
             & "HLine -> ( poserr: " & AR(position_error) & "; direrr: " & AR(direction_error) & ") ";
 }
-
+#endif // ULIB_SERIALIZATION_ON
 

src/Math/Dense.h

@@ -54,9 +54,6 @@
 #include <stdlib.h>
 
 #include <Eigen/Dense>
-#include "Core/Types.h"
-#include "Core/Serializable.h"
-
 
 
 //// BOOST SERIALIZATION ///////////////////////////////////////////////////////
@@ -109,6 +106,7 @@ std::ostream & operator << (std::ostream &os, const Eigen::Matrix<T,size,1> &vec
 
 namespace uLib {
 
+typedef id_t          Id_t;
 
 typedef int           Scalari;
 typedef unsigned int  Scalarui;
@@ -264,6 +262,9 @@ operator<< (std::ostream& stream, const HError3f &err) {
 ////////////////////////////////////////////////////////////////////////////////
 // SERIALIZTION //
 
+#ifdef ULIB_SERIALIZATION_ON
+#include "Core/Serializable.h"
+
 ULIB_SERIALIZABLE(uLib::HPoint3f)
 
 ULIB_SERIALIZABLE(uLib::HVector3f)
@@ -272,7 +273,7 @@ ULIB_SERIALIZABLE(uLib::HVector3f)
 ULIB_SERIALIZABLE(uLib::HLine3f)
 
 ULIB_SERIALIZABLE(uLib::HError3f)
-
+#endif // ULIB_SERIALIZATION_ON
 
 
 

src/Math/Geometry.h

@@ -28,7 +28,6 @@
 #ifndef U_GEOMETRY_H
 #define U_GEOMETRY_H
 
-#include "Core/Object.h"
 #include "Math/Dense.h"
 #include "Math/Transform.h"
 

src/Math/Quote.h

@@ -32,11 +32,11 @@
 
 namespace uLib {
 
-class Quote : public Vector2f {
+class Quote : public Vector2f
+{
 public:
 
-
+    inline Scalarf& Offset() { return this->m_Offset; }
-    uLibRefMacro(Offset,Scalarf);
 
 private:
     Scalarf m_Offset;

src/Math/Structured2DGrid.cpp

@@ -0,0 +1,130 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Sara Vanini < sara.vanini@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 "Structured2DGrid.h"
+
+using namespace uLib;
+
+//_____________________________________________________________
+Structured2DGrid::Structured2DGrid()
+{
+    // reset uni-dim space
+    m_Dims = Vector2i(0,0);
+    m_Origin = Vector2f(0.,0.);
+    m_Increments = Vector2i(0,0);
+    m_binW = Vector2f(1.,1.);
+    m_debug = true;
+}
+
+
+//_____________________________________________________________
+void Structured2DGrid::SetDims(const Vector2i &size)
+{
+    this->m_Dims = size;
+
+    // set increments
+    this->m_Increments[0] = 1;
+    this->m_Increments[1] = m_Dims[0];
+   }
+
+//_____________________________________________________________
+void Structured2DGrid::SetPhysicalSpace(const Vector2f &origin, const Vector2f &spacing)
+{
+    m_Origin = origin;
+    m_binW = spacing;
+
+    m_uni2phys_T = Translation<float,2>(m_Origin) * Scaling(m_binW);
+    m_phys2uni_T = m_uni2phys_T.matrix().inverse();
+
+    return;
+}
+
+
+//_____________________________________________________________
+bool Structured2DGrid::IsInsideBounds(const Vector2f &pt) const
+{
+    Vector2i pLoc = this->PhysicsToUnitSpace(pt);
+    return this->IsInsideGrid(pLoc);
+}
+
+
+//_____________________________________________________________
+Vector2i Structured2DGrid::UnMap(int index) const
+{
+    Vector2i v( 0,0 );
+    Vector2i iv = m_Increments;
+
+    int id = 0;
+    for(int k=0; k<2; ++k) {
+        int inc = iv.maxCoeff(&id);
+        v(id) = index / inc;
+        index -= v(id) * inc;
+        iv(id) = 0;
+    }
+    return v;
+}
+
+//_____________________________________________________________
+bool Structured2DGrid::IsInsideGrid(const Vector2i &v) const
+{
+    int vok = 1;
+    vok *= (v(0) >= 0 && v(0) < m_Dims[0]);
+    vok *= (v(1) >= 0 && v(1) < m_Dims[1]);
+
+    return vok;
+}
+
+
+//_____________________________________________________________
+Vector2i Structured2DGrid::PhysicsToUnitSpace(const Vector2f &pt) const
+{
+    Vector2i out;
+    Vector2f pLoc = m_phys2uni_T * pt;
+
+    out << (int)floor(pLoc(0)),
+                (int)floor(pLoc(1));
+
+    return out;
+}
+
+//_____________________________________________________________
+Vector2f Structured2DGrid::UnitToPhysicsSpace(const Vector2i &ind) const
+{
+    Vector2f p;
+    p = m_uni2phys_T * ind.cast<float>();
+
+    return p;
+}
+
+//_____________________________________________________________
+void Structured2DGrid::PrintSelf(std::ostream &o)
+{
+    o << "uLib Structured Data 2D: \n"
+      << "dim     = " << this->GetDims().transpose() << "\n"
+      << "spacing = " << this->GetSpacing().transpose() << "\n";
+}
+

src/Math/Structured2DGrid.h

@@ -0,0 +1,74 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Sara Vanini < sara.vanini@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef Structured2DGrid_H
+#define Structured2DGrid_H
+
+#include "Math/Dense.h"
+
+#include <Eigen/Dense>
+#include <Eigen/Geometry>
+
+using namespace Eigen;
+
+namespace uLib {
+
+class Structured2DGrid {
+public:
+
+    Structured2DGrid();
+
+    /// unit-space
+    void SetDims(const Vector2i &size);
+    inline Vector2i GetDims() {return m_Dims; }
+    bool IsInsideGrid(const Vector2i &v) const;
+    inline int Map(Vector2i index) const  { return (m_Increments.transpose() * index);}
+    Vector2i UnMap(int index) const;
+
+    /// physics-space
+    void SetPhysicalSpace(const Vector2f &origin, const Vector2f &spacing);
+    inline Vector2f GetSpacing() const {    return m_binW; }
+    inline Vector2f GetOrigin() const {    return m_Origin; }
+    bool IsInsideBounds(const Vector2f &pt) const;
+
+    /// operations
+    Vector2i PhysicsToUnitSpace(const Vector2f &pt) const;
+    Vector2f UnitToPhysicsSpace(const Vector2i &ind) const;
+    void PrintSelf(std::ostream &o);
+    void SetDebug(bool debug){ m_debug = debug; };
+
+private:
+    Vector2i m_Dims;
+    Vector2i m_Increments;
+    Vector2f m_binW;
+    Vector2f m_Origin;
+    bool m_debug;
+
+     Transform<float, 2, Eigen::Affine>  m_uni2phys_T;
+     Transform<float, 2, Eigen::Affine>  m_phys2uni_T;
+};
+}
+
+#endif // Structured2DGrid_H

src/Math/Structured4DGrid.cpp

@@ -0,0 +1,136 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 "Structured4DGrid.h"
+
+using namespace uLib;
+
+//_____________________________________________________________
+Structured4DGrid::Structured4DGrid()
+{
+    // reset uni-dim space
+    m_Dims = Vector4i(0,0,0,0);
+    m_Origin = Vector4f(0.,0.,0.,0.);
+    m_Increments = Vector4i(0,0,0,0);
+    m_binW = Vector4f(1.,1.,1.,1.);
+    m_debug = true;
+}
+
+
+//_____________________________________________________________
+void Structured4DGrid::SetDims(const Vector4i &size)
+{
+    this->m_Dims = size;
+
+    // set increments
+    this->m_Increments[0] = 1;
+    this->m_Increments[1] = m_Dims[0];
+    this->m_Increments[2] = m_Dims[0] * m_Dims[1];
+    this->m_Increments[3] = m_Dims[0] * m_Dims[1] * m_Dims[2];
+
+}
+
+//_____________________________________________________________
+void Structured4DGrid::SetPhysicalSpace(const Vector4f &origin, const Vector4f &spacing)
+{
+    m_Origin = origin;
+    m_binW = spacing;
+
+    m_uni2phys_T = Translation<float,4>(m_Origin) * Scaling(m_binW);
+    m_phys2uni_T = m_uni2phys_T.matrix().inverse();
+
+    return;
+}
+
+
+//_____________________________________________________________
+bool Structured4DGrid::IsInsideBounds(const Vector4f &pt) const
+{
+    Vector4i pLoc = this->PhysicsToUnitSpace(pt);
+    return this->IsInsideGrid(pLoc);
+}
+
+
+//_____________________________________________________________
+Vector4i Structured4DGrid::UnMap(int index) const
+{
+    Vector4i v( 0,0,0, 0 );
+    Vector4i iv = m_Increments;
+
+    int id = 0;
+    for(int k=0; k<4; ++k) {
+        int inc = iv.maxCoeff(&id);
+        v(id) = index / inc;
+        index -= v(id) * inc;
+        iv(id) = 0;
+    }
+    return v;
+}
+
+//_____________________________________________________________
+bool Structured4DGrid::IsInsideGrid(const Vector4i &v) const
+{
+    int vok = 1;
+    vok *= (v(0) >= 0 && v(0) < m_Dims[0]);
+    vok *= (v(1) >= 0 && v(1) < m_Dims[1]);
+    vok *= (v(2) >= 0 && v(2) < m_Dims[2]);
+    vok *= (v(3) >= 0 && v(3) < m_Dims[3]);
+    return vok;
+}
+
+
+//_____________________________________________________________
+Vector4i Structured4DGrid::PhysicsToUnitSpace(const Vector4f &pt) const
+{
+    Vector4i out;
+    Vector4f pLoc = m_phys2uni_T * pt;
+
+    out << (int)floor(pLoc(0)),
+                (int)floor(pLoc(1)),
+                (int)floor(pLoc(2)),
+                (int)floor(pLoc(3));
+
+    return out;
+}
+
+//_____________________________________________________________
+Vector4f Structured4DGrid::UnitToPhysicsSpace(const Vector4i &ind) const
+{
+    Vector4f p;
+    p = m_uni2phys_T * ind.cast<float>();
+
+    return p;
+}
+
+//_____________________________________________________________
+void Structured4DGrid::PrintSelf(std::ostream &o)
+{
+    o << "uLib Structured Data 4D: \n"
+      << "dim     = " << this->GetDims().transpose() << "\n"
+      << "spacing = " << this->GetSpacing().transpose() << "\n";
+}
+

src/Math/Structured4DGrid.h

@@ -0,0 +1,74 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef Structured4DGrid_H
+#define Structured4DGrid_H
+
+#include "Math/Dense.h"
+
+#include <Eigen/Dense>
+#include <Eigen/Geometry>
+
+using namespace Eigen;
+
+namespace uLib {
+
+class Structured4DGrid {
+public:
+
+    Structured4DGrid();
+
+    /// unit-space
+    void SetDims(const Vector4i &size);
+    inline Vector4i GetDims() {return m_Dims; }
+    bool IsInsideGrid(const Vector4i &v) const;
+    inline int Map(Vector4i index) const  { return (m_Increments.transpose() * index);}
+    Vector4i UnMap(int index) const;
+
+    /// physics-space
+    void SetPhysicalSpace(const Vector4f &origin, const Vector4f &spacing);
+    inline Vector4f GetSpacing() const {    return m_binW; }
+    inline Vector4f GetOrigin() const {    return m_Origin; }
+    bool IsInsideBounds(const Vector4f &pt) const;
+
+    /// operations
+    Vector4i PhysicsToUnitSpace(const Vector4f &pt) const;
+    Vector4f UnitToPhysicsSpace(const Vector4i &ind) const;
+    void PrintSelf(std::ostream &o);
+    void SetDebug(bool debug){ m_debug = debug; };
+
+private:
+    Vector4i m_Dims;
+    Vector4i m_Increments;
+    Vector4f m_binW;
+    Vector4f m_Origin;
+    bool m_debug;
+
+     Transform<float, 4, Eigen::Affine>  m_uni2phys_T;
+     Transform<float, 4, Eigen::Affine>  m_phys2uni_T;
+};
+}
+
+#endif // Structured4DGrid_H

src/Math/StructuredData.h

@@ -28,15 +28,12 @@
 #ifndef STRUCTUREDDATA_H
 #define STRUCTUREDDATA_H
 
-#include "Core/Macros.h"
-#include "Core/Object.h"
 #include "Math/Dense.h"
 
 namespace uLib {
 
-class StructuredData : public Object {
+class StructuredData {
 public:
-    typedef Object BaseClass;
     enum _Order
     {
         CustomOrder = 0,
@@ -53,22 +50,23 @@ public:
     StructuredData(const Vector3i &size);
 
     StructuredData(const StructuredData &copy) :
-        BaseClass(copy),
         m_DataOrder(copy.m_DataOrder),
         m_Dims(copy.m_Dims),
         m_Increments(copy.m_Increments)
     {}
 
 
-    uLibGetMacro(Dims,Vector3i)
+    inline Vector3i GetDims() const { return this->m_Dims; }
 
     void SetDims(const Vector3i &size);
 
-    uLibGetSetMacro(Increments,Vector3i)
+    inline Vector3i GetIncrements() const { return this->m_Increments; }
+
+    inline void SetIncrements(Vector3i name) { this->m_Increments = name; }
 
     void SetDataOrder(Order order = YXZ);
 
-    uLibGetMacro(DataOrder,Order)
+    inline Order GetDataOrder() const { return this->m_DataOrder; }
 
     bool IsInsideGrid(const Vector3i &v) const;
 

src/Math/StructuredGrid.h

@@ -28,7 +28,6 @@
 #ifndef U_MATH_STRUCTUREDGRID_H
 #define U_MATH_STRUCTUREDGRID_H
 
-#include "Core/Object.h"
 #include "Math/ContainerBox.h"
 #include "Math/StructuredData.h"
 

src/Math/Transform.h

@@ -49,7 +49,6 @@
 #ifndef U_TRANSFORM_H
 #define U_TRANSFORM_H
 
-#include <Core/Macros.h>
 #include <Eigen/Geometry>
 
 
@@ -80,7 +79,10 @@ public:
     {}
 
     Eigen::Affine3f& GetTransform() { return m_T; }
-    uLibGetSetMacro(Parent,AffineTransform *)
+
+    inline AffineTransform *GetParent() const { return this->m_Parent; }
+
+    inline void SetParent(AffineTransform *name) { this->m_Parent = name; }
 
     inline void SetMatrix (Matrix4f &mat) { m_T.matrix() = mat; }
     inline Matrix4f& GetMatrix () { return m_T.matrix(); }

src/Math/TriangleMesh.h

@@ -28,14 +28,14 @@
 #ifndef TRIANGLEMESH_H
 #define TRIANGLEMESH_H
 
-#include "Core/Object.h"
+#include <vector>
-#include "Core/Vector.h"
+
 #include "Math/Dense.h"
 
 namespace uLib {
 
-class TriangleMesh : public Object {
+class TriangleMesh
-
+{
 public:
     void PrintSelf(std::ostream &o);
 
@@ -44,12 +44,12 @@ public:
     void AddTriangle(const Id_t *id);
     void AddTriangle(const Vector3i &id);
 
-    uLibRefMacro(Points,Vector<Vector3f>)
+    inline std::vector<Vector3f> & Points() { return this->m_Points; }
-    uLibRefMacro(Triangles,Vector<Vector3i>)
+    inline std::vector<Vector3i> & Triangles() { return this->m_Triangles; }
 
 private:
-    Vector<Vector3f> m_Points;
+    std::vector<Vector3f> m_Points;
-    Vector<Vector3i> m_Triangles;
+    std::vector<Vector3i> m_Triangles;
 
 };
 

src/Math/VoxImage.h

@@ -28,13 +28,13 @@
 #ifndef U_MATH_VOXIMAGE_H
 #define U_MATH_VOXIMAGE_H
 
-#include "Core/Vector.h"
 #include "Core/StaticInterface.h"
 #include "Math/Dense.h"
 #include "Math/StructuredGrid.h"
 
 #include <iostream>
 #include <stdlib.h>
+#include <vector>
 
 namespace uLib {
 
@@ -104,8 +104,8 @@ public:
         this->m_Data = copy.m_Data;
     }
 
-    uLibRefMacro(Data,Vector<T>)
+    inline std::vector<T> & Data() { return this->m_Data; }
-    inline const Vector<T>& ConstData() const { return m_Data; }
+    inline const std::vector<T>& ConstData() const { return m_Data; }
 
     inline const T& At(int i)              const { return m_Data.at(i); }
     inline const T& At(const Vector3i &id) const { return m_Data.at(Map(id)); }
@@ -213,7 +213,7 @@ public:
     }
 
 private:
-    Vector<T> m_Data;
+    std::vector<T> m_Data;
 };
 
 

src/Math/VoxImageFilter.h

@@ -29,7 +29,6 @@
 #define VOXIMAGEFILTER_H
 
 #include "Core/StaticInterface.h"
-#include "Core/Object.h"
 #include "Math/Dense.h"
 
 #include "Math/VoxImage.h"
@@ -64,7 +63,7 @@ protected:
 
 
 template < typename VoxelT, typename AlgorithmT >
-class VoxImageFilter : public Abstract::VoxImageFilter, public Object
+class VoxImageFilter : public Abstract::VoxImageFilter
 {
 
 public:
@@ -72,7 +71,7 @@ public:
 
     void Run();
 
-    void SetKernelNumericXZY(const Vector<float> &numeric);
+    void SetKernelNumericXZY(const std::vector<float> &numeric);
 
     void SetKernelSpherical(float (*shape)(float));
 
@@ -84,9 +83,9 @@ public:
     template < class ShapeT >
     void SetKernelWeightFunction( ShapeT shape );
 
-    uLibGetMacro(KernelData,Kernel<VoxelT>)
+    inline Kernel<VoxelT> GetKernelData() const { return this->m_KernelData; }
 
-    uLibGetMacro(Image,VoxImage<VoxelT> *)
+    inline VoxImage<VoxelT>* GetImage() const { return this->m_Image; }
 
     void SetImage(Abstract::VoxImage *image);
 

src/Math/VoxImageFilter.hpp

@@ -48,14 +48,14 @@ public:
     inline T& operator[](const int &id) { return m_Data[id]; }
     inline int GetCenterData() const;
 
-    uLibRefMacro(Data,Vector<T>)
+    inline std::vector<T> & Data() { return this->m_Data; }
 
-    inline const Vector<T>& ConstData() const { return this->m_Data; }
+    inline const std::vector<T>& ConstData() const { return this->m_Data; }
 
     void PrintSelf(std::ostream &o) const;
 
 private:
-    Vector<T> m_Data;
+    std::vector<T> m_Data;
 };
 
 template < typename T >
@@ -163,7 +163,7 @@ float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v)
 
 
 _TPL_
-void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(const Vector<float> &numeric)
+void VoxImageFilter<_TPLT_>::SetKernelNumericXZY(const std::vector<float> &numeric)
 {
     // set data order //
     StructuredData::Order order = m_KernelData.GetDataOrder();
@@ -268,8 +268,8 @@ void VoxImageFilter<_TPLT_>::SetImage(Abstract::VoxImage *image)
 _TPL_
 float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer, int index)
 {
-    const Vector<VoxelT> &vbuf = buffer.ConstData();
+    const std::vector<VoxelT> &vbuf = buffer.ConstData();
-    const Vector<VoxelT> &vker = m_KernelData.ConstData();
+    const std::vector<VoxelT> &vker = m_KernelData.ConstData();
     int vox_size = vbuf.size();
     int ker_size = vker.size();
     int pos;

src/Math/VoxImageFilter2ndStat.hpp

@@ -50,8 +50,8 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;

src/Math/VoxImageFilterABTrim.hpp

@@ -59,13 +59,13 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
-        Vector<VoxelT> mfh(ker_size);
+        std::vector<VoxelT> mfh(ker_size);
         for (int i = 0; i < ker_size; ++i)
             mfh[i].Count = i; //index key for ordering function
         for (int ik = 0; ik < ker_size; ik++) {
@@ -126,13 +126,13 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
-        Vector<VoxelT> mfh(ker_size);
+        std::vector<VoxelT> mfh(ker_size);
         for (int i = 0; i < ker_size; ++i)
             mfh[i].Count = i; //index key for ordering function
         for (int ik = 0; ik < ker_size; ik++) {

src/Math/VoxImageFilterBilateral.hpp

@@ -50,8 +50,8 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
@@ -101,15 +101,15 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int img_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
 
 
-        Vector<FPair> mfh(ker_size);
+        std::vector<FPair> mfh(ker_size);
         for (int i = 0; i < ker_size; ++i)
             mfh[i].first = vker[i].Value; // kernel value in first
         for (int ik = 0; ik < ker_size; ik++) {

src/Math/VoxImageFilterCustom.hpp

@@ -32,6 +32,8 @@
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
 
+#define likely(expr) __builtin_expect(!!(expr), 1)
+
 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER CUSTOM  /////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -43,7 +45,7 @@ class VoxFilterAlgorithmCustom :
         public VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT> > {
 
 
-    typedef float (* FunctionPt)(const Vector<Scalarf> &);
+    typedef float (* FunctionPt)(const std::vector<Scalarf> &);
 public:
     typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT> > BaseClass;
     VoxFilterAlgorithmCustom(const Vector3i &size) :
@@ -53,14 +55,14 @@ public:
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
         if(likely(m_CustomEvaluate)) {
-            const Vector<VoxelT> &vbuf = buffer.ConstData();
+            const std::vector<VoxelT> &vbuf = buffer.ConstData();
-            const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+            const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
             int vox_size = vbuf.size();
             int ker_size = vker.size();
             int pos;
 
             float ker_sum = 0;
-            Vector<Scalarf> mfh(ker_size);
+            std::vector<Scalarf> mfh(ker_size);
             for (int ik = 0; ik < ker_size; ik++) {
                 pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
                 pos = (pos + vox_size) % vox_size;
@@ -76,7 +78,7 @@ public:
 
     }
 
-    uLibSetMacro(CustomEvaluate,FunctionPt)
+    inline void SetCustomEvaluate(FunctionPt funPt) { this->m_CustomEvaluate = funPt; }
 
 private:
     FunctionPt m_CustomEvaluate;

src/Math/VoxImageFilterLinear.hpp

@@ -48,8 +48,8 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;

src/Math/VoxImageFilterMedian.hpp

@@ -47,13 +47,13 @@ public:
 
     float Evaluate(const VoxImage<VoxelT> &buffer, int index)
     {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
+        const std::vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+        const std::vector<VoxelT> &vker = this->m_KernelData.ConstData();
         int vox_size = vbuf.size();
         int ker_size = vker.size();
         int pos;
 
-        Vector<float> mfh(ker_size);
+        std::vector<float> mfh(ker_size);
         for (int ik = 0; ik < ker_size; ik++) {
             pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
             pos = (pos + vox_size) % vox_size;

src/Math/VoxImageFilterUser.cpp

@@ -26,7 +26,6 @@
 
 
 
-#include "Core/Vector.h"
 #include "Dense.h"
 #include "VoxImage.h"
 #include "VoxImageFilterUser.h"

src/Math/VoxRaytracer.cpp

@@ -24,11 +24,13 @@
 //////////////////////////////////////////////////////////////////////////////*/
 
 
-
+#include <iostream>
 
 #include "VoxRaytracer.h"
 #include "Utils.h"
 
+#define unlikely(expr) __builtin_expect(!!(expr), 0)
+
 inline float fast_sign(float f) { return 1 - 2 * (f < 0); }
 
 namespace uLib {
@@ -80,7 +82,7 @@ void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in)
 void VoxRaytracer::RayData::PrintSelf(std::ostream &o)
 {
     o << "Ray: total lenght " << m_TotalLength << "\n";
-    Vector<Element>::Iterator it;
+    std::vector<Element>::iterator it;
     for(it = m_Data.begin(); it < m_Data.end(); ++it)
         o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
 }

src/Math/VoxRaytracer.h

@@ -29,8 +29,8 @@
 #define VOXRAYTRACER_H
 
 #include <math.h>
+#include <vector>
 
-#include "Core/Vector.h"
 #include "Math/StructuredGrid.h"
 
 namespace uLib {
@@ -51,14 +51,15 @@ public:
 
         void AppendRay ( const RayData &in);
 
-        uLibConstRefMacro(Data,Vector<Element>)
+        inline const std::vector<Element>& Data() const { return this->m_Data; }
-        uLibConstRefMacro(TotalLength,Scalarf)
+
+        inline const Scalarf& TotalLength() const { return this->m_TotalLength; }
 
         void PrintSelf(std::ostream &o);
 
     private:
-        Vector<Element> m_Data;
+        std::vector<Element> m_Data;
-        Scalarf         m_TotalLength;
+        Scalarf              m_TotalLength;
     };
 
 
@@ -78,7 +79,7 @@ public:
 
     RayData TraceLine(const HLine3f &line) const;
 
-    uLibGetMacro(Image,StructuredGrid *)
+    inline StructuredGrid* GetImage() const { return this->m_Image; }
 
 private:
     StructuredGrid *m_Image;

src/Math/testing/AccumulatorTest.cpp

@@ -44,14 +44,16 @@ int test_ABTrim() {
 
     acc.SetABTrim(1,1);
 
-    Vector<float> v;
+    std::vector<float> v;
-    v << 1,5,5,5,300;
+    for(float tmpf : {1,5,5,5,300}) v.push_back(tmpf);
+    //v << 1,5,5,5,300;
 
-    for(Vector<float>::Iterator itr=v.begin(); itr<v.end(); itr++)
+    for(std::vector<float>::iterator itr=v.begin(); itr<v.end(); itr++)
         acc += *itr;
 
-    std::cout << "Accumulating  Trim(1,1) vector: "
+    // TODO missing operator <<
-              << v << " ... out = " << acc() << "\n";
+    //std::cout << "Accumulating  Trim(1,1) vector: "
+    //          << v << " ... out = " << acc() << "\n";
 
     return( acc() == 15.0 );
 
@@ -62,7 +64,7 @@ int test_Mean() {
     Accumulator_Mean<float> mean;
     TRandom rnd;
     const int c = 10000000;
-    Vector<float> v;
+    std::vector<float> v;
     v.reserve(c);
     for(int i=0;i<c;++i) v.push_back( rnd.Gaus(2000,5) );
 

src/Math/testing/CMakeLists.txt

@@ -14,5 +14,9 @@ set(TESTS
         BitCodeTest
 )
 
+set(LIBRARIES
+       ${PACKAGE_LIBPREFIX}Core
+       ${PACKAGE_LIBPREFIX}Math
+)
 
 uLib_add_tests(${uLib-module})

src/Math/testing/VoxImageFilterTest.cpp

@@ -63,7 +63,7 @@ private:
 };
 
 
-static float MaxInVector(const Vector<float> &v)
+static float MaxInVector(const std::vector<float> &v)
 {
     float max = 0;
     for(int i=0; i<v.size(); ++i)
@@ -93,7 +93,7 @@ int main()
 
         VoxImage<TestVoxel> filtered = image;
 
-        Vector<float> values;
+        std::vector<float> values;
         for(int i=0; i < filter.GetKernelData().GetDims().prod(); ++i) {
             values.push_back(1.);
             std::cout << values[i] << " ";
@@ -128,7 +128,7 @@ int main()
 
         VoxFilterAlgorithmCustom<TestVoxel> filter(Vector3i(3,3,4));
 
-        Vector<float> values;
+        std::vector<float> values;
         for(int i=0; i < filter.GetKernelData().GetDims().prod(); ++i) {
             values.push_back(static_cast<float>(1));
         }

src/Math/testing/VoxRaytracerTest.cpp

@@ -94,7 +94,7 @@ int main()
         TEST1( pt == HPoint3f(-3,-3,-3) );
 
         Raytracer::RayData rdata = ray.TraceBetweenPoints(HPoint3f(-3,-3,-3), HPoint3f(3,3,3));
-        foreach (const Raytracer::RayData::Element &el, rdata.Data())
+        for(const Raytracer::RayData::Element &el : rdata.Data())
         {
             std::cout << " " << el.vox_id << " , " << el.L << "\n";
         }

src/Root/CMakeLists.txt

@@ -1,49 +1,64 @@
-set(HEADERS
+set(HEADERS TestTObject.h
- TestTObject.h
+            RootMathDense.h
- RootMathDense.h
+            RootMuonScatter.h
- RootMuonScatter.h
+            RootHitRaw.h
- RootHitRaw.h
+            muBlastHit.h
- muBlastHit.h
+            muBlastMCTrack.h
- muBlastMCTrack.h
+            muCastorMCTrack.h
- muCastorMCTrack.h
+            muCastorHit.h
- muCastorHit.h
+            muCastorInfo.h)
-)
 
-set(DICTIONARY_HEADERS
+set(DICTIONARY_HEADERS TestTObject.h
- TestTObject.h
+                       RootMathDense.h
- RootMathDense.h
+                       RootMuonScatter.h
- RootMuonScatter.h
+                       RootHitRaw.h
- RootHitRaw.h
+                       muBlastHit.h
- muBlastHit.h
+                       muBlastMCTrack.h
- muBlastMCTrack.h
+                       muCastorMCTrack.h
- muCastorMCTrack.h
+                       muCastorHit.h
- muCastorHit.h
+                       muCastorInfo.h)
-)
 
-SET(SOURCES
+set(SOURCES TestTObject.cpp
- TestTObject.cpp
+            RootMuonScatter.cpp
- RootMuonScatter.cpp
+            muBlastHit.cpp
- muBlastHit.cpp
+            muBlastMCTrack.cpp
- muBlastMCTrack.cpp
+            muCastorMCTrack.cpp
- muCastorMCTrack.cpp
+            muCastorHit.cpp
- muCastorHit.cpp
+            muCastorInfo.cpp)
-)
 
-set(LIBRARIES
+set(LIBRARIES ${ROOT_LIBRARIES}
-#       ${Boost_SERIALIZATION_LIBRARY}
+              ${PACKAGE_LIBPREFIX}Math)
-#       ${Boost_SIGNALS_LIBRARY}
-#       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-)
 
-include(FindROOTv6)
+set(rDictName ${PACKAGE_LIBPREFIX}RootDict)
-root_generate_dictionary(uLibRootDict ${DICTIONARY_HEADERS} LINKDEF Linkdef.h)
+root_generate_dictionary(${rDictName} ${DICTIONARY_HEADERS}
-set_source_files_properties(uLibRootDict.cxx PROPERTIES GENERATED TRUE)
+                         LINKDEF Linkdef.h)
-set_source_files_properties(uLibRootDict.h PROPERTIES GENERATED TRUE)
+set_source_files_properties(${rDictName}.cxx
-list(APPEND SOURCES     uLibRootDict.cxx)
+                            PROPERTIES GENERATED TRUE)
+set_source_files_properties(${rDictName}.h
+                            PROPERTIES GENERATED TRUE)
+list(APPEND SOURCES ${rDictName}.cxx)
+
+# TODO use a custom target linked to root_generate_dictionary
+set(R_ARTIFACTS ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}_rdict.pcm
+                   ${CMAKE_CURRENT_BINARY_DIR}/lib${rDictName}.rootmap)
+install(FILES ${R_ARTIFACTS}
+        DESTINATION ${PACKAGE_INSTALL_LIB_DIR})
+
+set(libname ${PACKAGE_LIBPREFIX}Root)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Root PARENT_SCOPE)
+
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
+target_link_libraries(${libname} ${LIBRARIES})
+
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Root)
 
 
-uLib_add_shared_library(${uLib-module})
-add_subdirectory(testing)

src/Root/Linkdef.h

@@ -78,6 +78,7 @@ using namespace ROOT::Mutom;
 #pragma link C++ class  muBlastHit+;
 #pragma link C++ class  muCastorMCTrack+;
 #pragma link C++ class  muCastorHit+;
+#pragma link C++ class  muCastorInfo+;
 
 #endif // __CINT__
 

src/Root/muBlastMCTrack.h

@@ -9,6 +9,7 @@
 //         Martin Subieta   martin.subieta@ing.unibs.it
 //########################################
 
+#include <iostream>
 #include <vector>
 #include "TObject.h"
 #include "TParticle.h"

src/Root/muCastorInfo.cpp

@@ -0,0 +1,44 @@
+//------------------------------------------------
+// The Virtual Monte Carlo examples
+// Copyright (C) 2007, 2008 Ivana Hrivnacova
+// All rights reserved.
+//
+// For the licensing terms see geant4_vmc/LICENSE.
+// Contact: vmc@pcroot.cern.ch
+//-------------------------------------------------
+
+/// \file muCastorInfo.cxx 
+/// \brief Implementation of the muCastorInfo class 
+///
+/// \author G. Bonomi, A. Donzella - INFN
+
+#include <iostream>
+
+#include "muCastorInfo.h"
+
+/// \cond CLASSIMP
+ClassImp(muCastorInfo)
+/// \endcond
+
+using namespace std;
+
+//_____________________________________________________________________________
+muCastorInfo::muCastorInfo() 
+  : fMuGen(-1)
+{
+/// Default constructor
+}
+//_____________________________________________________________________________
+muCastorInfo::~muCastorInfo() 
+{
+/// Destructor
+}
+//_____________________________________________________________________________
+void muCastorInfo::Print(const Option_t* /*opt*/) const
+{
+/// Printing
+
+  cout << "  Generated muons: " << fMuGen 
+       << endl;
+}
+

src/Root/muCastorInfo.h

@@ -0,0 +1,44 @@
+#ifndef muCastor_RUN_H
+#define muCastor_RUN_H
+
+//------------------------------------------------
+// The Virtual Monte Carlo examples
+// Copyright (C) 2007, 2008 Ivana Hrivnacova
+// All rights reserved.
+//
+// For the licensing terms see geant4_vmc/LICENSE.
+// Contact: vmc@pcroot.cern.ch
+//-------------------------------------------------
+
+/// \file muCastorInfo.h
+/// \brief Definition of the muCastorInfo class 
+///
+/// \authors G. Bonomi, A. Donzella - INFN
+
+#include <TObject.h>
+#include <TVector3.h>
+
+class muCastorInfo : public TObject
+{
+  public:
+    muCastorInfo();
+    virtual ~muCastorInfo();
+
+    // methods
+    virtual void Print(const Option_t* option = "") const;
+
+    void SetMuGen  (Int_t muGen)  { fMuGen = muGen; };
+    void SetMuTrk  (Int_t muTrk)  { fMuTrk = muTrk; };
+
+    Int_t GetMuGen()   { return fMuGen; };
+
+  private:
+    Int_t      fMuGen;   // Generated muons
+    Int_t      fMuTrk;   // Tracked muons
+    
+  ClassDef(muCastorInfo,1) //muCastorInfo  
+};
+
+#endif //muCastor_RUN_H
+
+

src/Root/muCastorMCTrack.cpp

@@ -6,11 +6,9 @@
 //         Martin Subieta   martin.subieta@ing.unibs.it
 //******************************************************************************************
 
-#include <iostream>
-
-#include "Detectors/MuonScatter.h"
 #include <Root/muCastorMCTrack.h>
 #include <TClonesArray.h>
+#include <iostream>
 
 using namespace std;
 
@@ -32,8 +30,6 @@ uLib::MuonScatter &operator << (uLib::MuonScatter &mu, const muCastorMCTrack &bs
     return mu;
 }
 
-//namespace ROOT {
-//namespace Mutom {
 // -----   Default constructor   -------------------------------------------
 muCastorMCTrack::muCastorMCTrack()
 {
@@ -223,5 +219,3 @@ void muCastorMCTrack::Reset()
    fPntE       = 0;
 
 }
-//} // Mutom
-//} // ROOT

src/Root/muCastorMCTrack.h

@@ -9,20 +9,14 @@
 //         Martin Subieta   martin.subieta@ing.unibs.it
 //########################################
 
+#include <iostream>
 #include "vector"
 #include "TObject.h"
 #include "TParticle.h"
+#include "Detectors/MuonScatter.h"
 
 class TClonesArray;
 
-
-namespace uLib {
-class MuonScatter;
-}
-
-//namespace ROOT {
-//namespace Mutom {
-
 class muCastorMCTrack : public TObject
 {
 
@@ -89,8 +83,6 @@ public:
   ClassDef(muCastorMCTrack,1);
 
 };
-//} // Mutom
-//} // ROOT
 
 uLib::MuonScatter &operator << (uLib::MuonScatter &mu, const muCastorMCTrack &bsmu);
 #endif //muCastor_MCTRACK_H   

src/Vtk/CMakeLists.txt

@@ -1,39 +1,38 @@
-set(HEADERS
+set(HEADERS uLibVtkInterface.h
-                          uLibVtkInterface.h
+            uLibVtkViewer.h
-                          uLibVtkViewer.h
+            vtkContainerBox.h
-                          vtkContainerBox.h
+            vtkMuonScatter.h
-                          vtkMuonScatter.h
+            vtkStructuredGrid.h
-                          vtkStructuredGrid.h
+            vtkVoxRaytracerRepresentation.h
-                          vtkVoxRaytracerRepresentation.h
+            vtkVoxImage.h)
-                          vtkVoxImage.h
-#                          vtkHLineRepresentation.h
-#			  vtkTriangleMesh.h
-)
 
-SET(SOURCES
+set(SOURCES uLibVtkInterface.cxx
-                uLibVtkInterface.cxx
+            uLibVtkViewer.cpp
-                uLibVtkViewer.cpp
+            vtkContainerBox.cpp
-                vtkContainerBox.cpp
+            vtkMuonScatter.cxx
-                vtkMuonScatter.cxx
+            vtkStructuredGrid.cpp
-                vtkStructuredGrid.cpp
+            vtkVoxRaytracerRepresentation.cpp
-                vtkVoxRaytracerRepresentation.cpp
+            vtkVoxImage.cpp)
-                vtkVoxImage.cpp
-)
 
-set(LIBRARIES
+set(LIBRARIES ${Eigen_LIBRARY}
-       ${Boost_SERIALIZATION_LIBRARY}
+              ${ROOT_LIBRARIES}
-       ${Boost_SIGNALS_LIBRARY}
+              ${VTK_LIBRARIES}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+              ${PACKAGE_LIBPREFIX}Math)
-       ${Eigen_LIBRARY}
-       ${ROOT_LIBRARIES}
-       ${Geant4_LIBRARIES}
-       ${VTK_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-       ${PACKAGE_LIBPREFIX}Detectors
-       ${PACKAGE_LIBPREFIX}Vtk
-)
 
-uLib_add_shared_library(${uLib-module})
+set(libname ${PACKAGE_LIBPREFIX}Vtk)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Vtk PARENT_SCOPE)
+
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
+target_link_libraries(${libname} ${LIBRARIES})
+
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/Vtk)
 
-add_subdirectory(testing)

src/Vtk/testing/CMakeLists.txt

@@ -9,5 +9,10 @@ set( TESTS
 #	vtkTriangleMeshTest
 )
 
+set(LIBRARIES
+       ${PACKAGE_LIBPREFIX}Core
+       ${PACKAGE_LIBPREFIX}Vtk
+)
+
 include(${VTK_USE_FILE})
 uLib_add_tests(${uLib-module})

src/Vtk/uLibVtkInterface.h

@@ -33,9 +33,6 @@
 #include <ostream>
 #include <iomanip>
 
-#include <Core/Vector.h>
-#include <Core/Object.h>
-
 
 
 // vtk classes forward declaration //
@@ -49,22 +46,8 @@ class vtkRendererCollection;
 namespace uLib {
 namespace Vtk {
 
-
+class Puppet
-
-//template <class T>
-//class Tie {
-
-//public:
-//    typedef T Content;
-
-
-//};
-
-
-
-class Puppet : public Object
 {
-    uLibTypeMacro(Puppet, Object)
 public:
     Puppet();
     ~Puppet();

src/Vtk/uLibVtkViewer.cpp

@@ -31,15 +31,11 @@
 #endif
 
 #include <vtkSmartPointer.h>
-#include <vtkRenderWindow.h>
-#include <vtkRenderer.h>
 #include <vtkRendererCollection.h>
 #include <vtkRenderWindowInteractor.h>
 
-#include <vtkCornerAnnotation.h>
 #include <vtkTextProperty.h>
 #include <vtkAxesActor.h>
-#include <vtkOrientationMarkerWidget.h>
 #include <vtkCamera.h>
 
 #include "uLibVtkViewer.h"
@@ -47,141 +43,114 @@
 namespace uLib {
 namespace Vtk {
 
-template <>
-class Tie<Viewer> {
-public:
-    void DoAction() {
-     std::cout << " VIEWER TIE !!! \n";
- }
-};
-
-
-//// PIMPL /////////////////////////////////////////////////////////////////////
-
-class ViewerPimpl {
-public:
-    ViewerPimpl() :
-        m_RenderWindow(vtkRenderWindow::New()),
-        m_Renderer(vtkRenderer::New()),
-        m_Annotation(vtkCornerAnnotation::New()),
-        m_Marker(vtkOrientationMarkerWidget::New())
-    {
-        this->InstallPipe();
-    }
-
-    ~ViewerPimpl() {
-        this->UninstallPipe();
-
-        m_Annotation->Delete();
-        m_Marker->Delete();
-        m_Renderer->Delete();
-        m_RenderWindow->Delete();
-    }
-
-    // members //
-    vtkRenderer                *m_Renderer;
-    vtkRenderWindow            *m_RenderWindow;
-    vtkCornerAnnotation        *m_Annotation;
-    vtkOrientationMarkerWidget *m_Marker;
-
-private:
-    void InstallPipe()
-    {
-        m_RenderWindow->AddRenderer(m_Renderer);
-        vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-                vtkSmartPointer<vtkRenderWindowInteractor>::New();
-        renderWindowInteractor->SetRenderWindow(m_RenderWindow);
-
-        // annotation //
-        m_Annotation->GetTextProperty()->SetColor(1,1,1);
-        m_Annotation->GetTextProperty()->SetFontFamilyToArial();
-        m_Annotation->GetTextProperty()->SetOpacity(0.5);
-        m_Annotation->SetMaximumFontSize(10);
-        m_Annotation->SetText(0,"uLib VTK Viewer - OpenCMT all right reserved.");
-        m_Renderer->AddViewProp(m_Annotation);
-
-        // orientation marker //
-        vtkSmartPointer<vtkAxesActor> axes =
-                vtkSmartPointer<vtkAxesActor>::New();
-        m_Marker->SetInteractor(renderWindowInteractor);
-        m_Marker->SetOrientationMarker(axes);
-        m_Marker->SetViewport(0.0,0.0,0.2,0.2);
-        m_Marker->SetEnabled(true);
-        m_Marker->InteractiveOff();
-
-        // Must be rendered here in Vtk-6.0 or seg-fault //
-        m_RenderWindow->Render();
-    }
-
-    void UninstallPipe() {
-        m_Renderer->RemoveAllViewProps();
-        m_Renderer->Clear();
-    }
-
-};
-
-
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ///// VTK VIEWER  //////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 
-Viewer::Viewer() : d(new ViewerPimpl) {}
+Viewer::Viewer() :
+    m_RenderWindow(vtkRenderWindow::New()),
+    m_Renderer(vtkRenderer::New()),
+    m_Annotation(vtkCornerAnnotation::New()),
+    m_Marker(vtkOrientationMarkerWidget::New())
+{
+    InstallPipe();
+}
 
-Viewer::~Viewer() { delete d; }
+Viewer::~Viewer()
+{
+    UninstallPipe();
 
+    m_Annotation->Delete();
+    m_Marker->Delete();
+    m_Renderer->Delete();
+    m_RenderWindow->Delete();
+}
+
+void Viewer::InstallPipe()
+{
+    m_RenderWindow->AddRenderer(m_Renderer);
+    vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
+            vtkSmartPointer<vtkRenderWindowInteractor>::New();
+    renderWindowInteractor->SetRenderWindow(m_RenderWindow);
+
+    // annotation //
+    m_Annotation->GetTextProperty()->SetColor(1,1,1);
+    m_Annotation->GetTextProperty()->SetFontFamilyToArial();
+    m_Annotation->GetTextProperty()->SetOpacity(0.5);
+    m_Annotation->SetMaximumFontSize(10);
+    m_Annotation->SetText(0,"uLib VTK Viewer - OpenCMT all right reserved.");
+    m_Renderer->AddViewProp(m_Annotation);
+
+    // orientation marker //
+    vtkSmartPointer<vtkAxesActor> axes =
+            vtkSmartPointer<vtkAxesActor>::New();
+    m_Marker->SetInteractor(renderWindowInteractor);
+    m_Marker->SetOrientationMarker(axes);
+    m_Marker->SetViewport(0.0,0.0,0.2,0.2);
+    m_Marker->SetEnabled(true);
+    m_Marker->InteractiveOff();
+
+    // Must be rendered here in Vtk-6.0 or seg-fault //
+    m_RenderWindow->Render();
+}
+
+void Viewer::UninstallPipe()
+{
+    m_Renderer->RemoveAllViewProps();
+    m_Renderer->Clear();
+}
 
 void Viewer::addProp(vtkProp *prop)
 {
-    d->m_Renderer->AddActor(prop);
+    m_Renderer->AddActor(prop);
-    d->m_Renderer->Render();
+    m_Renderer->Render();
 }
 
 void Viewer::RemoveProp(vtkProp *prop)
 {
-    d->m_Renderer->RemoveViewProp(prop);
+    m_Renderer->RemoveViewProp(prop);
-    d->m_Renderer->Render();
+    m_Renderer->Render();
 }
 
 void Viewer::AddPuppet(Puppet &prop)
 {
-    prop.ConnectRenderer(d->m_Renderer);
+    prop.ConnectRenderer(m_Renderer);
-    d->m_Renderer->Render();
+    m_Renderer->Render();
 }
 
 void Viewer::RemovePuppet(Puppet &prop)
 {
-    prop.DisconnectRenderer(d->m_Renderer);
+    prop.DisconnectRenderer(m_Renderer);
-    d->m_Renderer->Render();
+    m_Renderer->Render();
 }
 
 void Viewer::Start()
 {
-    d->m_RenderWindow->GetInteractor()->Start();
+    m_RenderWindow->GetInteractor()->Start();
 }
 
 vtkCornerAnnotation *Viewer::GetAnnotation()
 {
-    return d->m_Annotation;
+    return m_Annotation;
 }
 
 vtkRenderer *Viewer::GetRenderer()
 {
-    return d->m_Renderer;
+    return m_Renderer;
 }
 
 vtkRenderWindowInteractor *Viewer::GetInteractor()
 {
-    return d->m_RenderWindow->GetInteractor();
+    return m_RenderWindow->GetInteractor();
 }
 
 void Viewer::Reset()
 {
-    d->m_Renderer->ResetCameraClippingRange();
+    m_Renderer->ResetCameraClippingRange();
-    d->m_Renderer->ResetCamera();
+    m_Renderer->ResetCamera();
-    d->m_Renderer->Render();
+    m_Renderer->Render();
 }
 
 

src/Vtk/uLibVtkViewer.h

@@ -28,8 +28,13 @@
 #ifndef ULIBVTKVIEWER_H
 #define ULIBVTKVIEWER_H
 
+#include <iostream>
 #include "uLibVtkInterface.h"
 
+#include <vtkRenderer.h>
+#include <vtkRenderWindow.h>
+#include <vtkCornerAnnotation.h>
+#include <vtkOrientationMarkerWidget.h>
 
 class vtkProp;
 class vtk3DWidget;
@@ -78,10 +83,22 @@ public:
     void RemoveProp(vtkProp *prop);
 
 private:
-    class ViewerPimpl *d;
+    void InstallPipe();
+    void UninstallPipe();
+
+    vtkRenderer                *m_Renderer;
+    vtkRenderWindow            *m_RenderWindow;
+    vtkCornerAnnotation        *m_Annotation;
+    vtkOrientationMarkerWidget *m_Marker;
 };
 
-template <> class Tie<Viewer>;
+template <>
+class Tie<Viewer> {
+public:
+    void DoAction() {
+        std::cout << " VIEWER TIE !!! \n";
+    }
+};
 
 
 } // vtk

src/Vtk/vtkContainerBox.cpp

@@ -46,46 +46,20 @@ namespace uLib {
 namespace Vtk {
 
 
-// PIMPL -------------------------------------------------------------------- //
-
-class vtkContainerBoxPimpl {
-public:
-    vtkContainerBoxPimpl() :
-        m_Cube(vtkActor::New()),
-        m_Axes(vtkActor::New()),
-        m_Pivot(vtkActor::New()),
-        m_Content(NULL)
-    {}
-
-    ~vtkContainerBoxPimpl()
-    {
-        m_Cube->Delete();
-        m_Axes->Delete();
-        m_Pivot->Delete();
-    }
-
-    // MEMBERS //
-    vtkActor      *m_Cube;
-    vtkActor      *m_Axes;
-    vtkActor      *m_Pivot;
-    vtkContainerBox::Content *m_Content;
-};
-
-// -------------------------------------------------------------------------- //
-
-
-
-
 vtkContainerBox::vtkContainerBox(vtkContainerBox::Content &content) :
-    d( new vtkContainerBoxPimpl)
+    m_Cube(vtkActor::New()),
+    m_Axes(vtkActor::New()),
+    m_Pivot(vtkActor::New()),
+    m_Content(&content)
 {
-    d->m_Content = &content;
     this->InstallPipe();
 }
 
 vtkContainerBox::~vtkContainerBox()
 {
-    delete d;
+    m_Cube->Delete();
+    m_Axes->Delete();
+    m_Pivot->Delete();
 }
 
 vtkPolyData *vtkContainerBox::GetPolyData() const
@@ -95,8 +69,8 @@ vtkPolyData *vtkContainerBox::GetPolyData() const
 
 void vtkContainerBox::InstallPipe()
 {
-    if(!d->m_Content) return;
+    if(!m_Content) return;
-    Content *c = d->m_Content;
+    Content *c = m_Content;
 
     // CUBE
     vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
@@ -113,9 +87,9 @@ void vtkContainerBox::InstallPipe()
             vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputConnection(cube->GetOutputPort());
     mapper->Update();
-    d->m_Cube->SetMapper(mapper);
+    m_Cube->SetMapper(mapper);
-    d->m_Cube->GetProperty()->SetRepresentationToWireframe();
+    m_Cube->GetProperty()->SetRepresentationToWireframe();
-    d->m_Cube->GetProperty()->SetAmbient(0.7);
+    m_Cube->GetProperty()->SetAmbient(0.7);
 
     // AXES //
     vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
@@ -123,12 +97,12 @@ void vtkContainerBox::InstallPipe()
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputConnection(axes->GetOutputPort());
     mapper->Update();
-    d->m_Axes->SetMapper(mapper);
+    m_Axes->SetMapper(mapper);
     Vector3f s = c->GetSize();
-    //    d->m_Axes->SetScale(s(0),s(1),s(2));
+    //    m_Axes->SetScale(s(0),s(1),s(2));
-    d->m_Axes->GetProperty()->SetLineWidth(3);
+    m_Axes->GetProperty()->SetLineWidth(3);
-    d->m_Axes->GetProperty()->SetAmbient(0.4);
+    m_Axes->GetProperty()->SetAmbient(0.4);
-    d->m_Axes->GetProperty()->SetSpecular(0);
+    m_Axes->GetProperty()->SetSpecular(0);
 
     // PIVOT //
     axes = vtkSmartPointer<vtkAxes>::New();
@@ -136,16 +110,16 @@ void vtkContainerBox::InstallPipe()
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputConnection(axes->GetOutputPort());
     mapper->Update();
-    d->m_Pivot->SetMapper(mapper);
+    m_Pivot->SetMapper(mapper);
     s = c->GetScale();
-    //    d->m_Pivot->SetScale(s(0),s(1),s(2));
+    //    m_Pivot->SetScale(s(0),s(1),s(2));
-    d->m_Pivot->GetProperty()->SetLineWidth(3);
+    m_Pivot->GetProperty()->SetLineWidth(3);
-    d->m_Pivot->GetProperty()->SetAmbient(0.4);
+    m_Pivot->GetProperty()->SetAmbient(0.4);
-    d->m_Pivot->GetProperty()->SetSpecular(0);
+    m_Pivot->GetProperty()->SetSpecular(0);
 
-    this->SetProp(d->m_Cube);
+    this->SetProp(m_Cube);
-    this->SetProp(d->m_Axes);
+    this->SetProp(m_Axes);
-    this->SetProp(d->m_Pivot);
+    this->SetProp(m_Pivot);
 }
 
 

src/Vtk/vtkContainerBox.h

@@ -47,8 +47,10 @@ public:
 private:
     void InstallPipe();
 
-    friend class vtkContainerBoxPimpl;
+    vtkActor                 *m_Cube;
-    class vtkContainerBoxPimpl *d;
+    vtkActor                 *m_Axes;
+    vtkActor                 *m_Pivot;
+    vtkContainerBox::Content *m_Content;
 };
 
 } // vtk

src/Vtk/vtkMuonContainerScattering.h

@@ -30,7 +30,6 @@
 
 
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -66,8 +65,6 @@ protected:
 private:
     void InstallPipe();
 
-    friend class vtkMuonContainerScatteringPimpl;
-    class vtkMuonContainerScatteringPimpl *d;
 };
 
 

src/Vtk/vtkMuonEvent.cxx

@@ -29,22 +29,6 @@
 #include "config.h"
 #endif
 
-
-#include <vtkSmartPointer.h>
-#include <vtkSphereSource.h>
-#include <vtkAppendPolyData.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkLineSource.h>
-#include <vtkActor.h>
-
-#include <vtk3DWidget.h>
-#include <vtkBoxWidget.h>
-
-#include <vtkRenderWindowInteractor.h>
-
-#include <vtkCommand.h>
-#include <vtkTransform.h>
-
 #include "vtkMuonEvent.h"
 #include "Math/Dense.h"
 
@@ -72,105 +56,77 @@ private:
 };
 
 
-//// PIMPL /////////////////////////////////////////////////////////////////////
-
-class vtkMuonEventPimpl {
-    typedef vtkWidgetCallback Callback;
-public:
-    vtkMuonEventPimpl() :
-        m_Prop(vtkActor::New()),
-        m_PolyData(NULL),
-        m_Appender(vtkAppendPolyData::New()),
-        content(NULL)
-    {}
-
-    ~vtkMuonEventPimpl()
-    {
-        m_Prop->Delete();
-    }
-
-    // members //
-    vtkMuonEvent::Content *content;
-    vtkPolyData *m_PolyData;
-    vtkActor    *m_Prop;
-
-    vtkAppendPolyData *m_Appender;
-    vtkBoxWidget *m_WidgetIN, *m_WidgetOUT;
-    HPoint3f m_Poca;
-};
-
-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 /////  VTK MUON EVENT  /////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 
 vtkMuonEvent::vtkMuonEvent(MuonEventData &content) :
-    d(new vtkMuonEventPimpl)
+    m_Prop(vtkActor::New()),
+    m_PolyData(NULL),
+    m_Appender(vtkAppendPolyData::New()),
+    content(&content)
 {
-      d->content = &content;
+    InstallPipe();
-      InstallPipe();
 }
 
 vtkMuonEvent::vtkMuonEvent(const MuonEventData &content) :
-    d(new vtkMuonEventPimpl)
+    m_Prop(vtkActor::New()),
+    m_PolyData(NULL),
+    m_Appender(vtkAppendPolyData::New()),
+    content(const_cast<MuonEventData *>(&content))
 {
-      d->content = const_cast<MuonEventData *>(&content);
+    InstallPipe();
-      InstallPipe();
 }
 
 
 vtkMuonEvent::~vtkMuonEvent()
 {
-    if (d->m_Prop) d->m_Prop->Delete();
+    if (m_Prop) m_Prop->Delete();
 }
 
 vtkMuonEvent::Content &vtkMuonEvent::GetContent()
 {
-    return *d->content;
+    return *content;
 }
 
 void vtkMuonEvent::PrintSelf(std::ostream &o) const
 {
     o << "..:: MuonEvent ::..\n" \
-         "\t[in]  Origin    > " << d->content->LineIn().origin.transpose()    << "\n" <<
+         "\t[in]  Origin    > " << content->LineIn().origin.transpose()    << "\n" <<
-         "\t[in]  Direction > " << d->content->LineIn().direction.transpose() << "\n" <<
+         "\t[in]  Direction > " << content->LineIn().direction.transpose() << "\n" <<
-         "\t[out] Origin    > " << d->content->LineOut().origin.transpose()   << "\n" <<
+         "\t[out] Origin    > " << content->LineOut().origin.transpose()   << "\n" <<
-         "\t[out] Direction > " << d->content->LineOut().direction.transpose()<< "\n" <<
+         "\t[out] Direction > " << content->LineOut().direction.transpose()<< "\n" <<
-         "\tMomentum        > " << d->content->GetMomentum() << "\n" <<
+         "\tMomentum        > " << content->GetMomentum() << "\n" <<
          "...................\n";
 }
 
 vtkProp *vtkMuonEvent::GetProp()
 {
-    return d->m_Prop;
+    return m_Prop;
 }
 
 void vtkMuonEvent::InstallPipe()
 {
 
 
-    vtkAppendPolyData *appender = d->m_Appender;
+    vtkAppendPolyData *appender = m_Appender;
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
-    if(d->content) {
+    if(content) {
         vtkSmartPointer<vtkLineSource> line_in = vtkSmartPointer<vtkLineSource>::New();
         vtkSmartPointer<vtkLineSource> line_out = vtkSmartPointer<vtkLineSource>::New();
 
-        float distance = (d->content->LineIn().origin - d->content->LineOut().origin).norm() / 10;
+        float distance = (content->LineIn().origin - content->LineOut().origin).norm() / 10;
 
         HPoint3f pt;
-        pt = d->content->LineIn().origin;
+        pt = content->LineIn().origin;
         line_in->SetPoint1(pt(0),pt(1),pt(2));
-        pt= d->content->LineIn().origin + d->content->LineIn().direction * distance;
+        pt= content->LineIn().origin + content->LineIn().direction * distance;
         line_in->SetPoint2(pt(0),pt(1),pt(2));
-        pt = d->content->LineOut().origin;
+        pt = content->LineOut().origin;
         line_out->SetPoint1(pt(0),pt(1),pt(2));
-        pt = d->content->LineOut().origin + d->content->LineOut().direction * distance;
+        pt = content->LineOut().origin + content->LineOut().direction * distance;
         line_out->SetPoint2(pt(0),pt(1),pt(2));
 
         appender->AddInputConnection(line_in->GetOutputPort());
@@ -180,31 +136,31 @@ void vtkMuonEvent::InstallPipe()
     appender->Update();
     mapper->SetInputConnection(appender->GetOutputPort());
     mapper->Update();
-    d->m_Prop->SetMapper(mapper);
+    m_Prop->SetMapper(mapper);
 }
 
 vtkPolyData *vtkMuonEvent::GetPolyData() const
 {
-    return d->m_Appender->GetOutput();
+    return m_Appender->GetOutput();
 }
 
 void vtkMuonEvent::AddPocaPoint(HPoint3f poca)
 {
-    d->m_Poca = poca;
+    m_Poca = poca;
     vtkSmartPointer<vtkSphereSource> sphere =
             vtkSmartPointer<vtkSphereSource>::New();
-    float size = (d->content->LineIn().origin - d->content->LineOut().origin).head(3).norm();
+    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();
-    d->m_Appender->AddInputConnection(sphere->GetOutputPort());
+    m_Appender->AddInputConnection(sphere->GetOutputPort());
-    d->m_Appender->Update();
+    m_Appender->Update();
 }
 
 HPoint3f vtkMuonEvent::GetPocaPoint()
 {
-    return d->m_Poca;
+    return m_Poca;
 }
 
 

src/Vtk/vtkMuonEvent.h

@@ -28,7 +28,21 @@
 #ifndef VTKMUONEVENT_H
 #define VTKMUONEVENT_H
 
-#include "Core/Macros.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>
+
+#include <vtkRenderWindowInteractor.h>
+
+#include <vtkCommand.h>
+#include <vtkTransform.h>
+
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -64,8 +78,14 @@ public:
 private:
     void InstallPipe();
 
-    friend class vtkMuonEventPimpl;
+    vtkMuonEvent::Content *content;
-    class vtkMuonEventPimpl *d;
+    vtkPolyData           *m_PolyData;
+    vtkActor              *m_Prop;
+
+    vtkAppendPolyData     *m_Appender;
+    vtkBoxWidget          *m_WidgetIN;
+    vtkBoxWidget          *m_WidgetOUT;
+    HPoint3f               m_Poca;
 };
 
 

src/Vtk/vtkMuonScatter.cxx

@@ -30,23 +30,6 @@
 #include "config.h"
 #endif
 
-
-#include <vtkConfigure.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>
-
-#include <vtkRenderWindowInteractor.h>
-
-#include <vtkCommand.h>
-#include <vtkTransform.h>
-
 #include "vtkMuonScatter.h"
 #include "Math/Dense.h"
 
@@ -78,36 +61,6 @@ namespace Vtk {
 
 //}
 
-//// PIMPL /////////////////////////////////////////////////////////////////////
-
-class vtkMuonScatterPimpl {
-public:
-    vtkMuonScatterPimpl() :
-        m_Content(NULL),
-        m_LineIn(vtkLineSource::New()),
-        m_LineOut(vtkLineSource::New()),
-        m_PolyData(vtkPolyData::New()),
-        m_SpherePoca(NULL)
-    {}
-
-    ~vtkMuonScatterPimpl()
-    {
-        m_LineIn->Delete();
-        m_LineOut->Delete();
-        if(m_SpherePoca) m_SpherePoca->Delete();
-    }
-
-    // members //
-    vtkMuonScatter::Content *m_Content;
-    vtkLineSource   *m_LineIn, *m_LineOut;
-    vtkSphereSource *m_SpherePoca;
-    vtkPolyData *m_PolyData;
-};
-
-
-
-
-
 
 ////////////////////////////////////////////////////////////////////////////////
 /////  VTK MUON Scatter  /////////////////////////////////////////////////////////
@@ -115,63 +68,69 @@ public:
 
 
 vtkMuonScatter::vtkMuonScatter(MuonScatter &content) :
-    d(new vtkMuonScatterPimpl)
+    m_Content(&content),
+    m_LineIn(vtkLineSource::New()),
+    m_LineOut(vtkLineSource::New()),
+    m_PolyData(vtkPolyData::New()),
+    m_SpherePoca(NULL)
 {
-      d->m_Content = &content;
+    InstallPipe();
-      InstallPipe();
 }
 
 vtkMuonScatter::vtkMuonScatter(const MuonScatter &content) :
-    d(new vtkMuonScatterPimpl)
+    m_Content(const_cast<MuonScatter *>(&content)),
+    m_LineIn(vtkLineSource::New()),
+    m_LineOut(vtkLineSource::New()),
+    m_PolyData(vtkPolyData::New()),
+    m_SpherePoca(NULL)
 {
-      d->m_Content = const_cast<MuonScatter *>(&content);
+    InstallPipe();
-      InstallPipe();
 }
 
 
 vtkMuonScatter::~vtkMuonScatter()
 {
-    delete d;
+    m_LineIn->Delete();
+    m_LineOut->Delete();
+    if(m_SpherePoca) m_SpherePoca->Delete();
 }
 
 vtkMuonScatter::Content &vtkMuonScatter::GetContent()
 {
-    return *d->m_Content;
+    return *m_Content;
 }
 
 void vtkMuonScatter::PrintSelf(std::ostream &o) const
-{
+{}
-    //    o << d->content;
-}
 
 
 void vtkMuonScatter::InstallPipe()
 {
-    if(d->m_Content) {
+    if(m_Content) {
-        vtkLineSource *line_in = d->m_LineIn;
+        vtkLineSource *line_in = m_LineIn;
-        vtkLineSource *line_out = d->m_LineOut;
+        vtkLineSource *line_out = m_LineOut;
 
-        float distance = (d->m_Content->LineIn().origin - d->m_Content->LineOut().origin).norm() / 10;
+        float distance = (m_Content->LineIn().origin - m_Content->LineOut().origin).norm() / 10;
 
         HPoint3f pt;
-        pt = d->m_Content->LineIn().origin;
+        pt = m_Content->LineIn().origin;
         line_in->SetPoint1(pt(0),pt(1),pt(2));
-        pt= d->m_Content->LineIn().origin + d->m_Content->LineIn().direction * distance;
+        pt= m_Content->LineIn().origin + m_Content->LineIn().direction * distance;
         line_in->SetPoint2(pt(0),pt(1),pt(2));
-        pt = d->m_Content->LineOut().origin;
+        pt = m_Content->LineOut().origin;
         line_out->SetPoint1(pt(0),pt(1),pt(2));
-        pt = d->m_Content->LineOut().origin + d->m_Content->LineOut().direction * distance;
+        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(d->m_LineIn->GetOutputPort());
+    mapper->SetInputConnection(m_LineIn->GetOutputPort());
     vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
     this->SetProp(actor);
 
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(d->m_LineOut->GetOutputPort());
+    mapper->SetInputConnection(m_LineOut->GetOutputPort());
     actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
     this->SetProp(actor);
@@ -180,32 +139,26 @@ void vtkMuonScatter::InstallPipe()
 vtkPolyData *vtkMuonScatter::GetPolyData() const
 {
     vtkSmartPointer<vtkAppendPolyData> append = vtkSmartPointer<vtkAppendPolyData>::New();
-//#   if VTK_MAJOR_VERSION <= 5
+    append->AddInputConnection(m_LineIn->GetOutputPort());
-    append->AddInputConnection(d->m_LineIn->GetOutputPort());
+    append->AddInputConnection(m_LineOut->GetOutputPort());
-    append->AddInputConnection(d->m_LineOut->GetOutputPort());
+    if(m_SpherePoca) append->AddInputConnection(m_SpherePoca->GetOutputPort());
-    if(d->m_SpherePoca) append->AddInputConnection(d->m_SpherePoca->GetOutputPort());
-//#   else
-//    append->AddInputData(d->m_LineIn->GetOutput());
-//    append->AddInputData(d->m_LineOut->GetOutput());
-//    if(d->m_SpherePoca) append->AddInputData(d->m_SpherePoca->GetOutput());
-//#   endif
     append->Update();
-    d->m_PolyData->DeepCopy(append->GetOutput());
+    m_PolyData->DeepCopy(append->GetOutput());
-    return d->m_PolyData;
+    return m_PolyData;
 }
 
 void vtkMuonScatter::AddPocaPoint(HPoint3f poca)
 {
     vtkSphereSource *sphere = vtkSphereSource::New();
-    float size = (d->m_Content->LineIn().origin - d->m_Content->LineOut().origin).head(3).norm();
+    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();
-    d->m_SpherePoca = sphere;
+    m_SpherePoca = sphere;
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(d->m_SpherePoca->GetOutputPort());
+    mapper->SetInputConnection(m_SpherePoca->GetOutputPort());
     vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
     this->SetProp(actor);
@@ -214,8 +167,8 @@ void vtkMuonScatter::AddPocaPoint(HPoint3f poca)
 HPoint3f vtkMuonScatter::GetPocaPoint()
 {
     double center[3];
-    if(d->m_SpherePoca) {
+    if(m_SpherePoca) {
-        d->m_SpherePoca->GetCenter(center);
+        m_SpherePoca->GetCenter(center);
         return HPoint3f(center[0],center[1],center[2]);
     }
     else {

src/Vtk/vtkMuonScatter.h

@@ -28,7 +28,22 @@
 #ifndef VTKMUONSCATTER_H
 #define VTKMUONSCATTER_H
 
-#include "Core/Macros.h"
+#include <vtkConfigure.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>
+
+#include <vtkRenderWindowInteractor.h>
+
+#include <vtkCommand.h>
+#include <vtkTransform.h>
+
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -66,8 +81,11 @@ protected:
 private:
     void InstallPipe();
 
-    friend class vtkMuonScatterPimpl;
+    vtkMuonScatter::Content *m_Content;
-    class vtkMuonScatterPimpl *d;
+    vtkLineSource           *m_LineIn;
+    vtkLineSource           *m_LineOut;
+    vtkSphereSource         *m_SpherePoca;
+    vtkPolyData             *m_PolyData;
 };
 
 } // vtk

src/Vtk/vtkStructuredGrid.cpp

@@ -29,82 +29,12 @@
 #include "config.h"
 #endif
 
-#include <vtkLineSource.h>
-#include <vtkBoundingBox.h>
-#include <vtkCubeSource.h>
-#include <vtkSmartPointer.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkActor.h>
-#include <vtkProperty.h>
-
-#include <vtkTransform.h>
-#include <vtkTransformPolyDataFilter.h>
-#include <vtkBoxWidget.h>
-#include <vtkCommand.h>
-
 #include "Math/StructuredGrid.h"
 #include "Vtk/vtkStructuredGrid.h"
 
 namespace uLib {
 namespace Vtk {
 
-////////////////////////////////////////////////////////////////////////////////
-////// PIMPL  //////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-class vtkStructuredGridPimpl {
-
-    // ---- WIDGET CBK ------------------------------------------------------ //
-    class vtkWidgetCallback : public vtkCommand
-    {
-    public:
-      static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
-      void SetParent(uLib::Vtk::vtkStructuredGrid *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::vtkStructuredGrid *parent;
-    };
-    // ---------------------------------------------------------------------- //
-
-public:
-    vtkStructuredGridPimpl(vtkStructuredGrid *parent, StructuredGrid &content) :
-        p(parent),
-        m_Content(&content),
-        m_Actor(vtkActor::New()),
-        m_Widget(vtkBoxWidget::New()),
-        m_Transform(vtkTransform::New())
-    {
-        vtkSmartPointer<vtkWidgetCallback> callback =
-            vtkSmartPointer<vtkWidgetCallback>::New();
-        callback->SetParent(p);
-        m_Widget->AddObserver(vtkCommand::InteractionEvent, callback);
-    }
-
-    ~vtkStructuredGridPimpl()
-    {
-        m_Actor->Delete();
-        m_Widget->Delete();
-        m_Transform->Delete();
-    }
-
-    // members //
-    vtkActor       *m_Actor;
-    vtkBoxWidget   *m_Widget;
-    StructuredGrid *m_Content;
-    vtkTransform   *m_Transform;
-private:
-    vtkStructuredGrid *p;
-};
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////// VTK STRUCTURED GRID /////////////////////////////////////////////////////
@@ -113,14 +43,24 @@ private:
 
 
 vtkStructuredGrid::vtkStructuredGrid(Content &content) :
-    d(new vtkStructuredGridPimpl(this,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()
 {
-    delete d;
+    m_Actor->Delete();
+    m_Widget->Delete();
+    m_Transform->Delete();
 }
 
 
@@ -131,26 +71,26 @@ void vtkStructuredGrid::SetTransform(vtkTransform *t)
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             mat(i,j) = vmat->GetElement(i,j);
-    d->m_Content->SetMatrix(mat);
+    m_Content->SetMatrix(mat);
 
     vtkSmartPointer<vtkMatrix4x4> vmat2 = vtkSmartPointer<vtkMatrix4x4>::New();
-    mat = d->m_Content->GetWorldMatrix();
+    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));
-    d->m_Transform->SetMatrix(vmat2);
+    m_Transform->SetMatrix(vmat2);
-    d->m_Transform->Update();
+    m_Transform->Update();
     this->Update();
 }
 
 vtkBoxWidget *vtkStructuredGrid::GetWidget()
 {
-    return d->m_Widget;
+    return m_Widget;
 }
 
 void vtkStructuredGrid::Update()
 {
-    d->m_Actor->GetMapper()->Update();
+    m_Actor->GetMapper()->Update();
 }
 
 void vtkStructuredGrid::InstallPipe()
@@ -161,15 +101,15 @@ void vtkStructuredGrid::InstallPipe()
             vtkSmartPointer<vtkTransformPolyDataFilter>::New();
 
     vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-    Matrix4f mat = d->m_Content->GetWorldMatrix();
+    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));
-    d->m_Transform->SetMatrix(vmat);
+    m_Transform->SetMatrix(vmat);
-    filter->SetTransform(d->m_Transform);
+    filter->SetTransform(m_Transform);
     filter->SetInputConnection(cube->GetOutputPort());
 
-    Vector3i dims = d->m_Content->GetDims();
+    Vector3i dims = m_Content->GetDims();
     cube->SetBounds(0,dims(0),0,dims(1),0,dims(2));
     cube->Update();
     filter->Update();
@@ -178,16 +118,16 @@ void vtkStructuredGrid::InstallPipe()
             vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputConnection(filter->GetOutputPort());
 
-    d->m_Actor->SetMapper(mapper);
+    m_Actor->SetMapper(mapper);
-    d->m_Actor->GetProperty()->SetRepresentationToSurface();
+    m_Actor->GetProperty()->SetRepresentationToSurface();
-    d->m_Actor->GetProperty()->SetEdgeVisibility(true);
+    m_Actor->GetProperty()->SetEdgeVisibility(true);
-    d->m_Actor->GetProperty()->SetOpacity(0.4);
+    m_Actor->GetProperty()->SetOpacity(0.4);
-    d->m_Actor->GetProperty()->SetAmbient(0.7);
+    m_Actor->GetProperty()->SetAmbient(0.7);
     // set content transform to actor //
     this->Update();
-    d->m_Widget->SetProp3D(d->m_Actor);
+    m_Widget->SetProp3D(m_Actor);
 
-    this->SetProp(d->m_Actor);
+    this->SetProp(m_Actor);
 }
 
 

src/Vtk/vtkStructuredGrid.h

@@ -28,7 +28,19 @@
 #ifndef U_VTKSTRUCTUREDGRID_H
 #define U_VTKSTRUCTUREDGRID_H
 
-#include "Core/Macros.h"
+#include <vtkLineSource.h>
+#include <vtkBoundingBox.h>
+#include <vtkCubeSource.h>
+#include <vtkSmartPointer.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkActor.h>
+#include <vtkProperty.h>
+
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
+#include <vtkBoxWidget.h>
+#include <vtkCommand.h>
+
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -55,8 +67,28 @@ public:
 private:
     void InstallPipe();
 
-    friend class vtkStructuredGridPimpl;
+    class vtkWidgetCallback : public vtkCommand
-    class vtkStructuredGridPimpl *d;
+    {
+    public:
+        static vtkWidgetCallback *New() { return new vtkWidgetCallback; }
+
+        void SetGrid(uLib::Vtk::vtkStructuredGrid *grid) { this->grid = grid; }
+
+        virtual void Execute(vtkObject *caller, unsigned long, void*)
+        {
+          vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
+          vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
+          widget->GetTransform(t);
+          grid->SetTransform(t);
+        }
+    private:
+        uLib::Vtk::vtkStructuredGrid *grid;
+    };
+
+    vtkActor          *m_Actor;
+    vtkBoxWidget      *m_Widget;
+    StructuredGrid    *m_Content;
+    vtkTransform      *m_Transform;
 };
 
 

src/Vtk/vtkTriangleMesh.cpp

@@ -48,36 +48,7 @@
 namespace uLib {
 
 
-class vtkTriangleMeshPimpl {
+void vtkTriangleMesh::vtk2uLib_update()
-public:
-    vtkTriangleMeshPimpl(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);
-    }
-
-    ~vtkTriangleMeshPimpl() {
-        m_Poly->Delete();
-        m_Actor->Delete();
-    }
-
-
-    void vtk2uLib_update();
-    void uLib2vtk_update();
-
-    // members //
-    TriangleMesh &m_content;
-    vtkPolyData  *m_Poly;
-    vtkActor     *m_Actor;
-};
-
-
-void vtkTriangleMeshPimpl::vtk2uLib_update()
 {
     // Assumes that Polys are Triangles !!! //
     vtkIdType number_of_points = m_Poly->GetNumberOfPoints();
@@ -116,7 +87,7 @@ void vtkTriangleMeshPimpl::vtk2uLib_update()
     m_Actor->GetMapper()->Update();
 }
 
-void vtkTriangleMeshPimpl::uLib2vtk_update()
+void vtkTriangleMesh::uLib2vtk_update()
 {
     vtkIdType number_of_points = m_content.Points().size();
     vtkIdType number_of_triangles = m_content.Triangles().size();
@@ -161,12 +132,20 @@ void vtkTriangleMeshPimpl::uLib2vtk_update()
 
 
 vtkTriangleMesh::vtkTriangleMesh(vtkTriangleMesh::Content &content) :
-    d(new vtkTriangleMeshPimpl(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()
 {
-    delete d;
+    m_Poly->Delete();
+    m_Actor->Delete();
 }
 
 void vtkTriangleMesh::ReadFromFile(const char *filename)
@@ -175,8 +154,8 @@ void vtkTriangleMesh::ReadFromFile(const char *filename)
             vtkSmartPointer<vtkPolyDataReader>::New();
     reader->SetFileName(filename);
     reader->Update();
-    d->m_Poly->DeepCopy(reader->GetOutput());
+    m_Poly->DeepCopy(reader->GetOutput());
-    d->vtk2uLib_update();
+    vtk2uLib_update();
 }
 
 void vtkTriangleMesh::ReadFromXMLFile(const char *filename)
@@ -185,8 +164,8 @@ void vtkTriangleMesh::ReadFromXMLFile(const char *filename)
             vtkSmartPointer<vtkXMLPolyDataReader>::New();
     reader->SetFileName(filename);
     reader->Update();
-    d->m_Poly->DeepCopy(reader->GetOutput());
+    m_Poly->DeepCopy(reader->GetOutput());
-    d->vtk2uLib_update();
+    vtk2uLib_update();
 }
 
 void vtkTriangleMesh::ReadFromObjFile(const char *filename)
@@ -195,8 +174,8 @@ void vtkTriangleMesh::ReadFromObjFile(const char *filename)
             vtkSmartPointer<vtkOBJReader>::New();
     reader->SetFileName(filename);
     reader->Update();
-    d->m_Poly->DeepCopy(reader->GetOutput());
+    m_Poly->DeepCopy(reader->GetOutput());
-    d->vtk2uLib_update();
+    vtk2uLib_update();
 }
 
 void vtkTriangleMesh::ReadFromStlFile(const char *filename)
@@ -205,23 +184,23 @@ void vtkTriangleMesh::ReadFromStlFile(const char *filename)
             vtkSmartPointer<vtkSTLReader>::New();
     reader->SetFileName(filename);
     reader->Update();
-    d->m_Poly->DeepCopy(reader->GetOutput());
+    m_Poly->DeepCopy(reader->GetOutput());
-    d->vtk2uLib_update();
+    vtk2uLib_update();
 }
 
 vtkProp *vtkTriangleMesh::GetProp()
 {
-    return d->m_Actor;
+    return m_Actor;
 }
 
 vtkPolyData *vtkTriangleMesh::GetPolyData() const
 {
-    return d->m_Poly;
+    return m_Poly;
 }
 
 void vtkTriangleMesh::Update()
 {
-    d->uLib2vtk_update();
+    uLib2vtk_update();
 }
 
 }

src/Vtk/vtkTriangleMesh.h

@@ -58,8 +58,12 @@ public:
     void Update();
 
 private:
-    friend class vtkTriangleMeshPimpl;
+    void vtk2uLib_update();
-    class vtkTriangleMeshPimpl *d;
+    void uLib2vtk_update();
+
+    TriangleMesh &m_content;
+    vtkPolyData  *m_Poly;
+    vtkActor     *m_Actor;
 };
 
 

src/Vtk/vtkVoxImage.cpp

@@ -31,16 +31,12 @@
 
 
 #include <vtkSmartPointer.h>
-#include <vtkVolume.h>
-#include <vtkImageData.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 
 #include <vtkFloatArray.h>
 #include <vtkPointData.h>
 
-#include <vtkXMLImageDataReader.h>
-#include <vtkXMLImageDataWriter.h>
 #include <vtkGenericDataObjectReader.h>
 #include <vtkImageShiftScale.h>
 
@@ -51,7 +47,6 @@
 
 #include <vtkActor.h>
 #include <vtkProperty.h>
-#include <vtkCubeSource.h>
 #include <vtkPolyDataMapper.h>
 
 
@@ -63,53 +58,8 @@
 namespace uLib {
 namespace Vtk {
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// PIMPL
 
-class vtkVoxImagePimpl {
+void vtkVoxImage::GetContent()
-public:
-    vtkVoxImagePimpl(vtkVoxImage::Content &content) :
-        m_Content(content),
-        m_Actor(vtkVolume::New()),
-        m_Image(vtkImageData::New()),
-        m_Outline(vtkCubeSource::New()),
-        m_Reader(NULL),
-        m_Writer(NULL)
-    {}
-
-    ~vtkVoxImagePimpl()
-    {
-        m_Image->Delete();
-        m_Actor->Delete();
-        m_Outline->Delete();
-    }    
-
-    void GetContent();
-
-    void SetContent();
-
-    // members //
-    vtkVolume      *m_Actor;
-    vtkImageData   *m_Image;
-    vtkCubeSource  *m_Outline;
-
-    // io //
-    vtkXMLImageDataReader *m_Reader;
-    vtkXMLImageDataWriter *m_Writer;
-
-    // content //
-    vtkVoxImage::Content &m_Content;
-
-    // visual //
-    float m_Window;
-    float m_Level;
-};
-
-
-
-void vtkVoxImagePimpl::GetContent()
 {
     // ULIB -> VTK //
     const int *dims = static_cast<const int *>(m_Content.GetDims().data());
@@ -139,7 +89,7 @@ void vtkVoxImagePimpl::GetContent()
     //    m_Image->Update();
 }
 
-void vtkVoxImagePimpl::SetContent()
+void vtkVoxImage::SetContent()
 {
     // VTK -> ULIB //
     int *ext = m_Image->GetExtent();
@@ -181,22 +131,29 @@ void vtkVoxImagePimpl::SetContent()
 // VTK VOXIMAGE
 
 vtkVoxImage::vtkVoxImage(Content &content) :
-    d(new vtkVoxImagePimpl(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)
 {
-    init_properties();
+    GetContent();
-    d->GetContent();
     InstallPipe();
 }
 
 vtkVoxImage::~vtkVoxImage()
 {
-    delete d;
+    m_Image->Delete();
+    m_Actor->Delete();
+    m_Outline->Delete();
 }
 
 vtkImageData *vtkVoxImage::GetImageData()
 {
-    d->GetContent();
+    GetContent();
-    return d->m_Image;
+    return m_Image;
 }
 
 void vtkVoxImage::SaveToXMLFile(const char *fname)
@@ -204,16 +161,16 @@ void vtkVoxImage::SaveToXMLFile(const char *fname)
     vtkSmartPointer<vtkXMLImageDataWriter> writer =
             vtkSmartPointer<vtkXMLImageDataWriter>::New();
     writer->SetFileName(fname);
-    d->GetContent();
+    GetContent();
     vtkSmartPointer<vtkImageShiftScale> vtkscale =
             vtkSmartPointer<vtkImageShiftScale>::New();
 
 #   if VTK_MAJOR_VERSION <= 5
-    vtkscale->SetInputConnection(d->m_Image->GetProducerPort());
+    vtkscale->SetInputConnection(m_Image->GetProducerPort());
 #   else
-    vtkscale->SetInputData(d->m_Image);
+    vtkscale->SetInputData(m_Image);
 #   endif
-    vtkscale->SetScale(p().writer_factor);
+    vtkscale->SetScale(writer_factor);
     vtkscale->Update();
     writer->SetInputConnection(vtkscale->GetOutputPort());
     writer->Update();
@@ -231,16 +188,16 @@ void vtkVoxImage::ReadFromVKTFile(const char *fname)
         vtkSmartPointer<vtkImageShiftScale> vtkscale =
                 vtkSmartPointer<vtkImageShiftScale>::New();
         vtkscale->SetInputConnection(reader->GetOutputPort());
-        vtkscale->SetScale(1/p().writer_factor);
+        vtkscale->SetScale(1/writer_factor);
         vtkscale->Update();
 
-        d->m_Image->DeepCopy(vtkscale->GetOutput()); // FIX! (pipe connection)        
+        m_Image->DeepCopy(vtkscale->GetOutput()); // FIX! (pipe connection)
-        d->SetContent();
+        SetContent();
     }
     else {
         std::cerr << "Error: file does not contain structured points\n";
     }
-    d->m_Actor->Update();
+    m_Actor->Update();
 }
 
 void vtkVoxImage::ReadFromXMLFile(const char *fname)
@@ -252,25 +209,25 @@ void vtkVoxImage::ReadFromXMLFile(const char *fname)
     vtkSmartPointer<vtkImageShiftScale> vtkscale =
             vtkSmartPointer<vtkImageShiftScale>::New();
     vtkscale->SetInputConnection(reader->GetOutputPort());
-    vtkscale->SetScale(1/p().writer_factor);
+    vtkscale->SetScale(1/writer_factor);
     vtkscale->Update();
 
-    d->m_Image->DeepCopy(vtkscale->GetOutput());
+    m_Image->DeepCopy(vtkscale->GetOutput());
-    d->SetContent();
+    SetContent();
 }
 
 
 void vtkVoxImage::setShadingPreset(int blendType)
 {
     vtkSmartVolumeMapper *mapper =
-            (vtkSmartVolumeMapper *)d->m_Actor->GetMapper();
+            (vtkSmartVolumeMapper *)m_Actor->GetMapper();
-    vtkVolumeProperty  *property = d->m_Actor->GetProperty();
+    vtkVolumeProperty  *property = m_Actor->GetProperty();
 
     static vtkColorTransferFunction *colorFun = vtkColorTransferFunction::New();
     static vtkPiecewiseFunction *opacityFun = vtkPiecewiseFunction::New();
 
-    float window = 40 / $$.writer_factor;
+    float window = 40 / writer_factor;
-    float level  = 20 / $$.writer_factor;
+    float level  = 20 / writer_factor;
 
     property->SetColor(colorFun);
     property->SetScalarOpacity(opacityFun);
@@ -346,9 +303,9 @@ void vtkVoxImage::setShadingPreset(int blendType)
 }
 
 void vtkVoxImage::Update() {
-    d->m_Actor->Update();
+    m_Actor->Update();
-    d->m_Outline->SetBounds(d->m_Image->GetBounds());
+    m_Outline->SetBounds(m_Image->GetBounds());
-    d->m_Outline->Update();
+    m_Outline->Update();
 }
 
 void vtkVoxImage::InstallPipe()
@@ -356,26 +313,26 @@ void vtkVoxImage::InstallPipe()
     vtkSmartPointer<vtkSmartVolumeMapper> mapper =
             vtkSmartPointer<vtkSmartVolumeMapper>::New();
 #   if VTK_MAJOR_VERSION <= 5
-    mapper->SetInputConnection(d->m_Image->GetProducerPort());
+    mapper->SetInputConnection(m_Image->GetProducerPort());
 #   else
-    mapper->SetInputData(d->m_Image);
+    mapper->SetInputData(m_Image);
 #   endif
     mapper->Update();
 
-    d->m_Actor->SetMapper(mapper);
+    m_Actor->SetMapper(mapper);
     this->setShadingPreset(0);
     mapper->Update();
 
-    d->m_Outline->SetBounds(d->m_Image->GetBounds());
+    m_Outline->SetBounds(m_Image->GetBounds());
     vtkSmartPointer<vtkPolyDataMapper> mmapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mmapper->SetInputConnection(d->m_Outline->GetOutputPort());
+    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(d->m_Actor);
+    this->SetProp(m_Actor);
 }
 
 

src/Vtk/vtkVoxImage.h

@@ -28,7 +28,12 @@
 #ifndef U_VTKVOXIMAGE_H
 #define U_VTKVOXIMAGE_H
 
-#include <Core/Object.h>
+#include "vtk/vtkVolume.h"
+#include "vtk/vtkImageData.h"
+#include "vtk/vtkXMLImageDataReader.h"
+#include "vtk/vtkXMLImageDataWriter.h"
+#include "vtk/vtkCubeSource.h"
+
 #include <Math/VoxImage.h>
 
 #include "uLibVtkInterface.h"
@@ -39,14 +44,8 @@ class vtkImageData;
 namespace uLib {
 namespace Vtk {
 
-class vtkVoxImage : public Puppet {
+class vtkVoxImage : public Puppet
-    uLibTypeMacro(vtkVoxImage,Puppet)
+{
-public:    
-    properties()
-    {
-        float writer_factor;
-    };
-
 public:
     typedef Abstract::VoxImage Content;
 
@@ -54,6 +53,10 @@ public:
 
     ~vtkVoxImage();
 
+    void GetContent();
+
+    void SetContent();
+
     vtkImageData * GetImageData();
 
     void SaveToXMLFile(const char *fname);
@@ -67,20 +70,24 @@ public:
     void Update();
 
 protected:
-    void InstallPipe();
+    void    InstallPipe();
+    float   writer_factor;
 
 private:
-    class vtkVoxImagePimpl *d;
+    vtkVolume             *m_Actor;
+    vtkImageData          *m_Image;
+    vtkCubeSource         *m_Outline;
+
+    vtkXMLImageDataReader *m_Reader;
+    vtkXMLImageDataWriter *m_Writer;
+
+    vtkVoxImage::Content  &m_Content;
+
+    float                  m_Window;
+    float                  m_Level;
+
 };
 
-
-inline void vtkVoxImage::init_properties()
-{
-    $_init();
-    $$.writer_factor = 1.E6;
-}
-
-
 } // vtk
 } // uLib
 

src/Vtk/vtkVoxRaytracerRepresentation.cpp

@@ -29,25 +29,6 @@
 #include "config.h"
 #endif
 
-#include <vtkLine.h>
-#include <vtkCellArray.h>
-
-#include <vtkLineSource.h>
-#include <vtkSphereSource.h>
-#include <vtkBoundingBox.h>
-#include <vtkCubeSource.h>
-#include <vtkSmartPointer.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkAppendPolyData.h>
-#include <vtkActor.h>
-#include <vtkAssembly.h>
-#include <vtkProp3DCollection.h>
-#include <vtkProperty.h>
-#include <vtkPolyData.h>
-#include <vtkTransform.h>
-#include <vtkTransformPolyDataFilter.h>
-
-
 
 #include "vtkVoxRaytracerRepresentation.h"
 
@@ -60,59 +41,6 @@
 namespace uLib {
 namespace Vtk {
 
-///// PIMPL ////////////////////////////////////////////////////////////////////
-
-class vtkVoxRaytracerRepresentationPimpl {
-
-public:
-    vtkVoxRaytracerRepresentationPimpl(VoxRaytracer &content) :
-        m_Content(&content),
-        m_Assembly(vtkAssembly::New()),
-        m_Sphere1(vtkSphereSource::New()),
-        m_Sphere2(vtkSphereSource::New()),
-        m_Line1(vtkLineSource::New()),
-        m_Line2(vtkLineSource::New()),
-        m_Line3(vtkLineSource::New()),
-        m_RayLine(vtkAppendPolyData::New()),
-        m_RayLineActor(vtkActor::New()),
-        m_RayRepresentation(vtkAppendPolyData::New()),
-        m_RayRepresentationActor(vtkActor::New()),
-        m_Transform(vtkTransform::New())
-    {
-        default_radius = content.GetImage()->GetSpacing()(0)/4;
-        m_Sphere1->SetRadius(default_radius);
-        m_Sphere2->SetRadius(default_radius);
-        m_SelectedElement = m_RayLine;
-    }
-    ~vtkVoxRaytracerRepresentationPimpl()
-    {
-        m_Assembly->Delete();
-        m_RayLine->Delete();
-        m_RayLineActor->Delete();
-        m_RayRepresentationActor->Delete();
-        m_Transform->Delete();
-    }
-
-    // members //
-    VoxRaytracer *m_Content;
-
-    Scalarf                            default_radius;
-    vtkAssembly                       *m_Assembly;
-    vtkAppendPolyData                 *m_RayLine;
-    vtkActor                          *m_RayLineActor;
-    vtkActor                          *m_RayRepresentationActor;
-    vtkSmartPointer<vtkTransform>      m_Transform;
-    VoxRaytracer::RayData              m_Ray;
-    vtkSmartPointer<vtkSphereSource>   m_Sphere1,m_Sphere2;
-    vtkSmartPointer<vtkLineSource>     m_Line1,  m_Line2, m_Line3;
-    vtkSmartPointer<vtkAppendPolyData> m_RayRepresentation;
-
-    vtkAppendPolyData                *m_SelectedElement;
-};
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////// VOX RAYTRACER REPRESENTATION  ///////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -120,44 +48,64 @@ public:
 
 
 vtkVoxRaytracerRepresentation::vtkVoxRaytracerRepresentation(Content &content) :
-    d(new vtkVoxRaytracerRepresentationPimpl(content))
+    m_Content(&content),
+    m_Assembly(vtkAssembly::New()),
+    m_Sphere1(vtkSphereSource::New()),
+    m_Sphere2(vtkSphereSource::New()),
+    m_Line1(vtkLineSource::New()),
+    m_Line2(vtkLineSource::New()),
+    m_Line3(vtkLineSource::New()),
+    m_RayLine(vtkAppendPolyData::New()),
+    m_RayLineActor(vtkActor::New()),
+    m_RayRepresentation(vtkAppendPolyData::New()),
+    m_RayRepresentationActor(vtkActor::New()),
+    m_Transform(vtkTransform::New())
 {
+    default_radius = content.GetImage()->GetSpacing()(0)/4;
+    m_Sphere1->SetRadius(default_radius);
+    m_Sphere2->SetRadius(default_radius);
+    m_SelectedElement = m_RayLine;
+
     InstallPipe();
 }
 
 vtkVoxRaytracerRepresentation::~vtkVoxRaytracerRepresentation()
 {
-    delete d;
+    m_Assembly->Delete();
+    m_RayLine->Delete();
+    m_RayLineActor->Delete();
+    m_RayRepresentationActor->Delete();
+    m_Transform->Delete();
 }
 
 VoxRaytracer *vtkVoxRaytracerRepresentation::GetRaytracerAlgorithm()
 {
-    return d->m_Content;
+    return m_Content;
 }
 
 vtkProp *vtkVoxRaytracerRepresentation::GetProp()
 {
-    return d->m_Assembly;
+    return m_Assembly;
 }
 
 vtkPolyData *vtkVoxRaytracerRepresentation::GetPolyData() const
 {
     std::cout << "get Raytracer polydata\n";
-    d->m_SelectedElement->Update();
+    m_SelectedElement->Update();
-    return d->m_SelectedElement->GetOutput();
+    return m_SelectedElement->GetOutput();
 }
 
 void vtkVoxRaytracerRepresentation::SetRepresentationElements(vtkVoxRaytracerRepresentation::RepresentationElements el)
 {
     switch(el) {
     case Vtk::vtkVoxRaytracerRepresentation::RayElements:
-        d->m_SelectedElement = d->m_RayLine;
+        m_SelectedElement = m_RayLine;
         break;
     case Vtk::vtkVoxRaytracerRepresentation::VoxelsElements:
-        d->m_SelectedElement = d->m_RayRepresentation;
+        m_SelectedElement = m_RayRepresentation;
         break;
     default:
-        d->m_SelectedElement = d->m_RayLine;
+        m_SelectedElement = m_RayLine;
         break;
     }
 }
@@ -167,22 +115,22 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon)
 {
     HPoint3f pt1,pt2,src;
     src = muon.LineIn().origin;
-    d->m_Content->GetEntryPoint(muon.LineIn(),pt1);
+    m_Content->GetEntryPoint(muon.LineIn(),pt1);
-    d->m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
+    m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
-    d->m_Line1->SetPoint1(src(0),src(1),src(2));
+    m_Line1->SetPoint1(src(0),src(1),src(2));
-    d->m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
+    m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
 
     HLine3f line_out = muon.LineOut();
     src = line_out.origin;
     float *direction = line_out.direction.data();
     for(int i=0;i<3;++i) direction[i] *= -1;
-    d->m_Content->GetEntryPoint(line_out,pt2);
+    m_Content->GetEntryPoint(line_out,pt2);
-    d->m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
+    m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
-    d->m_Line2->SetPoint1(src(0),src(1),src(2));
+    m_Line2->SetPoint1(src(0),src(1),src(2));
-    d->m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
 
-    d->m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
+    m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
-    d->m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
 
     // Create a vtkPoints object and store the points in it
       vtkSmartPointer<vtkPoints> points =
@@ -210,25 +158,22 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon)
       // Add the lines to the dataset
       linesPolyData->SetLines(lines);
 
-      d->m_RayLine->RemoveAllInputs();
+      m_RayLine->RemoveAllInputs();
 #     if VTK_MAJOR_VERSION <= 5
-      d->m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
+      m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
-#     else
-      d->m_RayLine->AddInputData(linesPolyData);
 #     endif
-      d->m_RayLine->AddInputConnection(d->m_Line1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Line2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line2->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere2->GetOutputPort());
-//      d->m_RayLine->AddInputConnection(d->m_Line3->GetOutputPort());
 
 
     vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-    Matrix4f mat = d->m_Content->GetImage()->GetWorldMatrix();
+    Matrix4f mat = m_Content->GetImage()->GetWorldMatrix();
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             vmat->SetElement(i,j,mat(i,j));
-    d->m_Transform->SetMatrix(vmat);
+    m_Transform->SetMatrix(vmat);
 
     this->SetRay(pt1,pt2);
 }
@@ -237,22 +182,22 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca)
 {
     HPoint3f pt1,pt2,src;
     src = muon.LineIn().origin;
-    d->m_Content->GetEntryPoint(muon.LineIn(),pt1);
+    m_Content->GetEntryPoint(muon.LineIn(),pt1);
-    d->m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
+    m_Sphere1->SetCenter(pt1(0),pt1(1),pt1(2));
-    d->m_Line1->SetPoint1(src(0),src(1),src(2));
+    m_Line1->SetPoint1(src(0),src(1),src(2));
-    d->m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
+    m_Line1->SetPoint2(pt1(0),pt1(1),pt1(2));
 
     HLine3f line_out = muon.LineOut();
     src = line_out.origin;
     float *direction = line_out.direction.data();
     for(int i=0;i<3;++i) direction[i] *= -1;
-    d->m_Content->GetEntryPoint(line_out,pt2);
+    m_Content->GetEntryPoint(line_out,pt2);
-    d->m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
+    m_Sphere2->SetCenter(pt2(0),pt2(1),pt2(2));
-    d->m_Line2->SetPoint1(src(0),src(1),src(2));
+    m_Line2->SetPoint1(src(0),src(1),src(2));
-    d->m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line2->SetPoint2(pt2(0),pt2(1),pt2(2));
 
-    d->m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
+    m_Line3->SetPoint1(pt1(0),pt1(1),pt1(2));
-    d->m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
+    m_Line3->SetPoint2(pt2(0),pt2(1),pt2(2));
 
     // Create a vtkPoints object and store the points in it
       vtkSmartPointer<vtkPoints> points =
@@ -284,34 +229,31 @@ void vtkVoxRaytracerRepresentation::SetMuon(MuonScatter &muon, HPoint3f poca)
       // Add the lines to the dataset
       linesPolyData->SetLines(lines);
 
-      d->m_RayLine->RemoveAllInputs();
+      m_RayLine->RemoveAllInputs();
 #     if VTK_MAJOR_VERSION <= 5
-      d->m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
+      m_RayLine->AddInputConnection(linesPolyData->GetProducerPort());
-#     else
-      d->m_RayLine->AddInputData(linesPolyData);
 #     endif
-      d->m_RayLine->AddInputConnection(d->m_Line1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere1->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere1->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Line2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Line2->GetOutputPort());
-      d->m_RayLine->AddInputConnection(d->m_Sphere2->GetOutputPort());
+      m_RayLine->AddInputConnection(m_Sphere2->GetOutputPort());
-//      d->m_RayLine->AddInputConnection(d->m_Line3->GetOutputPort());
 
 
       vtkSmartPointer<vtkSphereSource> poca_sphere =
               vtkSmartPointer<vtkSphereSource>::New();
-      poca_sphere->SetRadius(d->default_radius);
+      poca_sphere->SetRadius(default_radius);
       poca_sphere->SetCenter(poca(0),poca(1),poca(2));
-      d->m_RayLine->AddInputConnection(poca_sphere->GetOutputPort());
+      m_RayLine->AddInputConnection(poca_sphere->GetOutputPort());
 
 
     vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-    Matrix4f mat = d->m_Content->GetImage()->GetWorldMatrix();
+    Matrix4f mat = m_Content->GetImage()->GetWorldMatrix();
     for(int i=0; i<4; ++i)
         for(int j=0; j<4; ++j)
             vmat->SetElement(i,j,mat(i,j));
-    d->m_Transform->SetMatrix(vmat);
+    m_Transform->SetMatrix(vmat);
 
-    if(d->m_Content->GetImage()->IsInsideBounds(poca))
+    if(m_Content->GetImage()->IsInsideBounds(poca))
         this->SetRay(pt1,poca,pt2);
     else
         this->SetRay(pt1,pt2);
@@ -328,38 +270,36 @@ void vtkVoxRaytracerRepresentation::SetMuon(vtkMuonScatter &muon)
 
 VoxRaytracer::RayData vtkVoxRaytracerRepresentation::GetRay()
 {
-    return d->m_Ray;
+    return m_Ray;
 }
 
 void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f out)
 {
-    d->m_Ray = d->m_Content->TraceBetweenPoints(in,out);
+    m_Ray = m_Content->TraceBetweenPoints(in,out);
-    this->SetRay(&d->m_Ray);
+    this->SetRay(&m_Ray);
 }
 
 void vtkVoxRaytracerRepresentation::SetRay(HPoint3f in, HPoint3f mid, HPoint3f out)
 {
-    d->m_Ray = d->m_Content->TraceBetweenPoints(in,mid);
+    m_Ray = m_Content->TraceBetweenPoints(in,mid);
-    d->m_Ray.AppendRay( d->m_Content->TraceBetweenPoints(mid,out) );
+    m_Ray.AppendRay( m_Content->TraceBetweenPoints(mid,out) );
-    this->SetRay(&d->m_Ray);
+    this->SetRay(&m_Ray);
 }
 
 void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray)
 {
-    vtkAppendPolyData *appender = d->m_RayRepresentation;
+    vtkAppendPolyData *appender = m_RayRepresentation;
     appender->RemoveAllInputs();
 
     for(int i=0; i<ray->Data().size(); ++i) {
         int id = ray->Data().at(i).vox_id;
-        Vector3i idv = d->m_Content->GetImage()->UnMap(id);
+        Vector3i idv = m_Content->GetImage()->UnMap(id);
         vtkSmartPointer<vtkCubeSource> cube =
                 vtkSmartPointer<vtkCubeSource>::New();
         cube->SetBounds(idv(0),idv(0)+1,idv(1),idv(1)+1,idv(2),idv(2)+1);
         cube->Update();
 #       if VTK_MAJOR_VERSION <= 5
         appender->AddInput(cube->GetOutput());
-#       else
-        appender->AddInputData(cube->GetOutput());
 #       endif
         appender->Update();
     }
@@ -368,12 +308,12 @@ void vtkVoxRaytracerRepresentation::SetRay(VoxRaytracer::RayData *ray)
 
 void vtkVoxRaytracerRepresentation::SetVoxelsColor(Vector4f rgba)
 {
-    this->SetColor(d->m_RayRepresentationActor,rgba);
+    this->SetColor(m_RayRepresentationActor,rgba);
 }
 
 void vtkVoxRaytracerRepresentation::SetRayColor(Vector4f rgba)
 {
-    this->SetColor(d->m_RayLineActor,rgba);
+    this->SetColor(m_RayLineActor,rgba);
 }
 
 void vtkVoxRaytracerRepresentation::SetColor(vtkActor *actor, Vector4f rgba)
@@ -395,10 +335,10 @@ void vtkVoxRaytracerRepresentation::InstallPipe()
 
     vtkSmartPointer<vtkAppendPolyData> append =
             vtkSmartPointer<vtkAppendPolyData>::New();
-    append->AddInputConnection(d->m_Sphere1->GetOutputPort());
+    append->AddInputConnection(m_Sphere1->GetOutputPort());
-    append->AddInputConnection(d->m_Sphere2->GetOutputPort());
+    append->AddInputConnection(m_Sphere2->GetOutputPort());
-    append->AddInputConnection(d->m_Line1->GetOutputPort());
+    append->AddInputConnection(m_Line1->GetOutputPort());
-    append->AddInputConnection(d->m_Line2->GetOutputPort());
+    append->AddInputConnection(m_Line2->GetOutputPort());
 
     append->Update();
     vtkSmartPointer<vtkPolyDataMapper> mapper =
@@ -413,34 +353,24 @@ void vtkVoxRaytracerRepresentation::InstallPipe()
     this->SetProp(actor);
 
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    mapper->SetInputConnection(d->m_RayLine->GetOutputPort());
+    mapper->SetInputConnection(m_RayLine->GetOutputPort());
     mapper->Update();
 
-    d->m_RayLineActor->SetMapper(mapper);
+    m_RayLineActor->SetMapper(mapper);
-    d->m_RayLineActor->GetProperty()->SetColor(1,0,0);
+    m_RayLineActor->GetProperty()->SetColor(1,0,0);
-    this->SetProp(d->m_RayLineActor);
+    this->SetProp(m_RayLineActor);
-
-//    mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-//    mapper->SetInputConnection(d->m_Line3->GetOutputPort());
-//    mapper->Update();
-
-//    actor = vtkSmartPointer<vtkActor>::New();
-//    actor->SetMapper(mapper);
-//    actor->GetProperty()->SetColor(1,0,0);
-//    d->m_Assembly->AddPart(actor);
-
 
     vtkSmartPointer<vtkTransformPolyDataFilter> polyfilter =
             vtkSmartPointer<vtkTransformPolyDataFilter>::New();
 
-    polyfilter->SetInputConnection(d->m_RayRepresentation->GetOutputPort());
+    polyfilter->SetInputConnection(m_RayRepresentation->GetOutputPort());
-    polyfilter->SetTransform(d->m_Transform);
+    polyfilter->SetTransform(m_Transform);
 
     mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputConnection(polyfilter->GetOutputPort());
     mapper->Update();
 
-    vtkActor *vra = d->m_RayRepresentationActor;
+    vtkActor *vra = m_RayRepresentationActor;
     vra->SetMapper(mapper);
     vra->GetProperty()->SetOpacity(0.2);
     vra->GetProperty()->SetEdgeVisibility(true);

src/Vtk/vtkVoxRaytracerRepresentation.h

@@ -28,8 +28,24 @@
 #ifndef U_VTKVOXRAYTRACERREPRESENTATION_H
 #define U_VTKVOXRAYTRACERREPRESENTATION_H
 
+#include <vtkLine.h>
+#include <vtkCellArray.h>
+
+#include <vtkLineSource.h>
+#include <vtkSphereSource.h>
+#include <vtkBoundingBox.h>
+#include <vtkCubeSource.h>
+#include <vtkSmartPointer.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkAppendPolyData.h>
+#include <vtkActor.h>
+#include <vtkAssembly.h>
+#include <vtkProp3DCollection.h>
+#include <vtkProperty.h>
+#include <vtkPolyData.h>
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
 
-#include "Core/Macros.h"
 #include "Math/Dense.h"
 
 #include "uLibVtkInterface.h"
@@ -89,8 +105,23 @@ private:
 
     void SetColor(vtkActor *actor, Vector4f rgba);
 
-    friend class vtkVoxRaytracerRepresentationPimpl;
+    VoxRaytracer                      *m_Content;
-    class vtkVoxRaytracerRepresentationPimpl *d;
+
+    Scalarf                            default_radius;
+    vtkAssembly                       *m_Assembly;
+    vtkAppendPolyData                 *m_RayLine;
+    vtkActor                          *m_RayLineActor;
+    vtkActor                          *m_RayRepresentationActor;
+    vtkSmartPointer<vtkTransform>      m_Transform;
+    VoxRaytracer::RayData              m_Ray;
+    vtkSmartPointer<vtkSphereSource>   m_Sphere1;
+    vtkSmartPointer<vtkSphereSource>   m_Sphere2;
+    vtkSmartPointer<vtkLineSource>     m_Line1;
+    vtkSmartPointer<vtkLineSource>     m_Line2;
+    vtkSmartPointer<vtkLineSource>     m_Line3;
+    vtkSmartPointer<vtkAppendPolyData> m_RayRepresentation;
+
+    vtkAppendPolyData                 *m_SelectedElement;
 };
 
 

src/ltk/main.C

@@ -1,35 +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 "Object.h"
-
-
-int main()
-{
-  return 0;
-}

uLibConfig.cmake.in

@@ -9,11 +9,7 @@ get_filename_component(ULIB_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
 set(ULIB_INCLUDE_DIRS "@CONF_INCLUDE_DIRS@")
 
 # Our library dependencies (contains definitions for IMPORTED targets)
-# if(NOT TARGET foo AND NOT FooBar_BINARY_DIR)
+include("${ULIB_CMAKE_DIR}/uLibTargets.cmake")
-  include("${ULIB_CMAKE_DIR}/uLibTargets.cmake")
-# endif()
 
 # These are IMPORTED targets created by FooBarTargets.cmake
-# set(FOOBAR_LIBRARIES foo)
-# set(FOOBAR_EXECUTABLE bar)
 set(ULIB_LIBRARIES @ULIB_SHARED_LIBRARIES@)