feat: disable camera spin/inertia by introducing a custom interactor style.r

Update .gitea/workflows/publish-docs.yaml
2026-03-06 17:31:29 +00:00 · 2026-03-06 17:52:45 +01:00 · 2026-03-06 17:51:53 +01:00 · 2026-03-06 17:50:13 +01:00 · 2026-03-06 17:17:52 +01:00 · 2026-03-06 10:45:33 +00:00
194 changed files with 10272 additions and 10001 deletions
--- a/.clangd
+++ b/.clangd
@@ -0,0 +1,52 @@
+CompileFlags:
+  CompilationDatabase: build
+  Add: 
+    - -I/home/rigoni/devel/cmt/ulib/src
+    - -isystem/home/share/micromamba/envs/mutom/include
+    - -isystem/home/share/micromamba/envs/mutom/include/eigen3
+    - -isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include
+    - -isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++
+    - -isystem/isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu
+    - -isystem/home/share/micromamba/envs/mutom/x86_64-conda-linux-gnu/sysroot/usr/include
+    - "--gcc-toolchain=/home/share/micromamba/envs/mutom"
+    - -D_ULIB_DETAIL_SIGNAL_EMIT
+    - -DUSE_CUDA
+    - -std=c++17
+    - "-D__host__="
+    - "-D__device__="
+    - "-D__global__="
+    - "-D__constant__="
+    - "-D__shared__="
+    - "-D__align__(x)="
+    - "-D__forceinline__=inline"
+    - "-D__launch_bounds__(x)="
+
+Diagnostics:
+  UnusedIncludes: None
+  MissingIncludes: None
+
+---
+If:
+  PathExclude: [/home/rigoni/devel/cmt/ulib/src/.*]
+Diagnostics:
+  Suppress: ["*"]
+
+---
+If:
+  PathMatch: [.*\.cu, .*/src/Math/testing/VoxRaytracerTest.cpp, .*/src/Math/VoxRaytracer.cpp, .*/src/Math/VoxImage.cpp]
+CompileFlags:
+  Add: 
+    - "-x"
+    - "cuda"
+    - "--cuda-path=/home/share/micromamba/envs/mutom"
+    - "--cuda-gpu-arch=sm_61"
+    - "--gcc-toolchain=/home/share/micromamba/envs/mutom"
+    - "-L/home/share/micromamba/envs/mutom/lib"
+    - "-lcudart"
+    - "-lcuda"
+    - "-U__host__"
+    - "-U__device__"
+    - "-U__global__"
+    - "-U__constant__"
+    - "-U__shared__"
+    - "-U__forceinline__"
--- a/.gitea/workflows/publish-docs.yaml
+++ b/.gitea/workflows/publish-docs.yaml
@@ -0,0 +1,42 @@
+name: MkDocs Subpath Deploy
+
+on:
+  workflow_dispatch: # trigger manuale
+  push:
+    branches:
+      - main  # Trigger on main branch
+
+jobs:
+  build-and-deploy:
+    runs-on: mildpub # Runner that can access to SSH_YFINPUB_HOST
+    
+    steps:
+      - name: Checkout del codice
+        uses: actions/checkout@v4
+
+      - name: Configura Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Installa dipendenze
+        run: |
+          python -m pip install --upgrade pip
+          pip install mkdocs-material 
+          pip install -r docs/docker/requirements.txt
+
+      - name: Build del sito
+        run: mkdocs build
+
+      - name: Deploy via SSH (SCP)
+        uses: https://github.com/appleboy/scp-action@master
+        with:
+          host: ${{ vars.SSH_YFINPUB_HOST }}
+          username: ${{ vars.SSH_YFINPUB_USER }}
+          key: ${{ secrets.MILD_PUB }}
+          port: 22
+          source: "site/*"
+          # Il percorso sul server deve corrispondere alla tua sottopagina
+          target: "/var/www/docs/cmt/uLib/"
+          strip_components: 1 # Rimuove la cartella "site/" e mette solo il contenuto
+          rm: true            # Pulisce la cartella prima di copiare (opzionale, stile Vercel)
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,15 @@
+CMakeFiles/
+build/
+.cache/
+build_warnings*.log
+final_build.log
+cmake_configure.log
+compile_commands.json
+
+dist/
+build_python/
+src/Python/uLib/*.so*
+src/Python/uLib/*.pyd
+src/Python/uLib/*.pyc
+src/Python/uLib/__pycache__
+src/Python/uLib/.nfs*
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,32 @@
+{
+    "clangd.fallbackFlags": [
+        "-I/home/rigoni/devel/cmt/ulib/src",
+        "-isystem/home/share/micromamba/envs/mutom/include",
+        "-isystem/home/share/micromamba/envs/mutom/include/eigen3",
+        "-isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include",
+        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
+        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
+        "-isystem/home/share/micromamba/envs/mutom/x86_64-conda-linux-gnu/sysroot/usr/include",
+        "--gcc-toolchain=/home/share/micromamba/envs/mutom",
+        "-D__host__=",
+        "-D__device__=",
+        "-D__global__=",
+        "-D__constant__=",
+        "-D__shared__=",
+        "-DUSE_CUDA",
+        "-D__CUDACC__"
+    ],
+    "clangd.semanticHighlighting.enable": true,
+    "clangd.arguments": [
+        "--compile-commands-dir=build",
+        "--query-driver=/home/share/micromamba/envs/mutom/bin/g++,/home/share/micromamba/envs/mutom/bin/gcc,/home/share/micromamba/envs/mutom/bin/nvcc",
+        "--suppress-system-warnings",
+        "--all-scopes-completion",
+        "--completion-style=detailed",
+        "--header-insertion=never",
+        "-j=4",
+        "--pch-storage=memory",
+        "--background-index",
+        "--log=verbose"
+    ]
+}
--- a/CMake/FindVTK.cmake.bak
+++ b/CMake/FindVTK.cmake.bak
--- a/CMake/uLibCommon.cmake
+++ b/CMake/uLibCommon.cmake
@@ -15,16 +15,16 @@ set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin CACHE PATH "build path for
 mark_as_advanced(EXECUTABLE_OUTPUT_PATH)

 ## Install directories ##
-set(PACKAGE_INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
-set(PACKAGE_INSTALL_LIB_DIR lib/${PACKAGE_NAME} CACHE PATH "Installation directory for libraries")
-set(PACKAGE_INSTALL_INC_DIR include/${PACKAGE_NAME} CACHE PATH "Installation directory for headers")
-set(PACKAGE_INSTALL_DATA_DIR share/${PACKAGE_NAME} CACHE PATH "Installation directory for data files")
+set(INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
+set(INSTALL_LIB_DIR lib/${PACKAGE_NAME} CACHE PATH "Installation directory for libraries")
+set(INSTALL_INC_DIR include/${PACKAGE_NAME} CACHE PATH "Installation directory for headers")
+set(INSTALL_DATA_DIR share/${PACKAGE_NAME} CACHE PATH "Installation directory for data files")
 if(WIN32 AND NOT CYGWIN)
 set(DEF_INSTALL_CMAKE_DIR CMake)
 else()
 set(DEF_INSTALL_CMAKE_DIR lib/cmake/${PACKAGE_NAME})
 endif()
-set(PACKAGE_INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
+set(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")

 # Make relative paths absolute (needed later on)
 foreach(p LIB BIN INC DATA CMAKE)
@@ -58,7 +58,7 @@ 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} -std=c++0x ${CMAKE_CXX_WARNING_OPTION}")



--- a/CMake/uLibConfigHeader.cmake
+++ b/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)
--- a/CMake/uLibFindDependencies.cmake
+++ b/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)
-message(STATUS "## GEANT 4 ##")
-#include(FindGEANT4) # disabled using system finder
-find_package(Geant4)
-set(GEANT4_FOUND Geant4_DIR)
-if(GEANT4_FOUND AND ULIB_USE_GEANT4)
- message(STATUS "Looking for Geant4... - Geant4 found in ${Geant4_DIR}")
- set(HAVE_GEANT4 true)
- include_directories(${Geant4_INCLUDE_DIRS})         # Add -I type paths
- add_definitions(${Geant4_DEFINITIONS})              # Add -D type defs
- debug_package(Geant4)
-endif(GEANT4_FOUND AND ULIB_USE_GEANT4)
+#option(ULIB_USE_GEANT4 "Activate use of GEANT Integration" ON)
+#message(STATUS "## GEANT 4 ##")
+##include(FindGEANT4) # disabled using system finder
+#find_package(Geant4)
+#set(GEANT4_FOUND Geant4_DIR)
+#if(GEANT4_FOUND AND ULIB_USE_GEANT4)
+# message(STATUS "Looking for Geant4... - Geant4 found in ${Geant4_DIR}")
+# set(HAVE_GEANT4 true)
+# include_directories(${Geant4_INCLUDE_DIRS})         # Add -I type paths
+# add_definitions(${Geant4_DEFINITIONS})              # Add -D type defs
+# debug_package(Geant4)
+#endif(GEANT4_FOUND AND ULIB_USE_GEANT4)

 ## QT4 ##
-option(ULIB_USE_QT4 "Activate use of Qt Framework" ON)
-if(ULIB_USE_QT4)
- message(STATUS "## QT4 ##")
- find_package(Qt4)
-# include_directories(${Qt4_INCLUDE_DIRS})
-# debug(Qt4_INCLUDE_DIRS)
-endif(ULIB_USE_QT4)
+#option(ULIB_USE_QT4 "Activate use of Qt Framework" ON)
+#if(ULIB_USE_QT4)
+# message(STATUS "## QT4 ##")
+# find_package(Qt4)
+## include_directories(${Qt4_INCLUDE_DIRS})
+## debug(Qt4_INCLUDE_DIRS)
+#endif(ULIB_USE_QT4)

 ## QT5 ##
-option(ULIB_USE_QT5 "Activate use of Qt Framework" ON)
-if(ULIB_USE_QT5)
- message(STATUS "## QT5 ##")
- find_package(Qt5Widgets)
-# include_directories(${Qt5_INCLUDE_DIRS})
-# debug(Qt5_INCLUDE_DIRS)
-endif(ULIB_USE_QT5)
+#option(ULIB_USE_QT5 "Activate use of Qt Framework" ON)
+#if(ULIB_USE_QT5)
+# message(STATUS "## QT5 ##")
+# find_package(Qt5Widgets)
+## include_directories(${Qt5_INCLUDE_DIRS})
+## debug(Qt5_INCLUDE_DIRS)
+#endif(ULIB_USE_QT5)

 ## READLINE ##
 message(STATUS "## READLINE ##")
--- a/CMake/uLibGenerateDoc.cmake
+++ b/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))
--- a/CMake/uLibTargetMacros.cmake
+++ b/CMake/uLibTargetMacros.cmake
@@ -30,24 +30,26 @@ macro(uLib_add_shared_library name)
  set_target_properties(${mname} PROPERTIES
                        VERSION ${PROJECT_VERSION}
                        SOVERSION ${PROJECT_SOVERSION}
-                      INTERFACE_LINK_LIBRARIES "${LIBRARIES}"
-                      LINK_INTERFACE_LIBRARIES "${LIBRARIES}"          ## <- ok for cmake from  2.12 ?
-                      IMPORTED_LINK_INTERFACE_LIBRARIES "${LIBRARIES}" ## <- breaks cmake after 2.11 ?
+#                       INTERFACE_LINK_LIBRARIES "${LIBRARIES}"
+#                       LINK_INTERFACE_LIBRARIES "${LIBRARIES}"          ## <- ok for cmake from  2.12 ?
+#                       IMPORTED_LINK_INTERFACE_LIBRARIES "${LIBRARIES}" ## <- breaks cmake after 2.11 ?
 #                       PUBLIC_HEADER ""
  )
  debug(LIBRARIES)

+  target_link_libraries(${mname} ${LIBRARIES})
+
  install(TARGETS ${mname}
         EXPORT "${PROJECT_NAME}Targets"
-         RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
-         LIBRARY DESTINATION ${PACKAGE_INSTALL_LIB_DIR} COMPONENT lib
-  #         PUBLIC_HEADER DESTINATION ${PACKAGE_INSTALL_INC_DIR} COMPONENT dev
+         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib
+  #         PUBLIC_HEADER DESTINATION ${INSTALL_INC_DIR} COMPONENT dev
  )
 endif(SOURCES)

 if(HEADERS)
  foreach(header ${HEADERS})
-   install(FILES ${header} DESTINATION ${PACKAGE_INSTALL_INC_DIR}/${name})
+   install(FILES ${header} DESTINATION ${INSTALL_INC_DIR}/${name})
  endforeach(header)
  endif(HEADERS)

@@ -68,7 +70,7 @@ macro(uLib_add_target name)

    install(TARGETS ${name}
            EXPORT "${PROJECT_NAME}Targets"
-            RUNTIME DESTINATION ${PACKAGE_INSTALL_BIN_DIR} COMPONENT bin
+            RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
           )
 ENDMACRO(uLib_add_target)

@@ -80,24 +82,18 @@ ENDMACRO(uLib_add_target)
 # TESTS and LIBRARIES must be defined
 macro(uLib_add_tests name)
    foreach(tn ${TESTS})
-  add_executable(${tn} EXCLUDE_FROM_ALL ${tn}.cpp)
-  add_test(${tn} ${tn})
+        add_executable(${tn} ${tn}.cpp)
+        add_test(NAME ${tn} COMMAND ${tn})

-  # adds dependencies to all selected modules in uLib
-  #  foreach(module ${ULIB_SELECTED_MODULES})
-  #   add_dependencies(${tn} ${project_name}${module})
-  #  endforeach(module)
-
-  # adds libraries dependencies
-  foreach(library ${LIBRARIES})
-   target_link_libraries(${tn} ${library})
-  endforeach(library)
+        target_link_libraries(${tn} ${LIBRARIES})

    endforeach(tn)

    # custom target to compile all tests
    add_custom_target(all-${name}-tests)
+    if(TESTS)
        add_dependencies(all-${name}-tests ${TESTS})
+    endif()
 endmacro(uLib_add_tests name)


--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,20 +3,35 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################

-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 3.26)
+if(POLICY CMP0167)
+    cmake_policy(SET CMP0167 NEW)
+endif()

-execute_process(COMMAND "clear")
-message("//////////////////////////////////////////////////////////////////////")
-message("/////////////////// CMAKE PJOJECT CONFIGURATION //////////////////////")
-message("//////////////////////////////////////////////////////////////////////")

 ## -------------------------------------------------------------------------- ##

 project(uLib)

+# CUDA Toolkit seems to be missing locally. Toggle ON if nvcc is made available.
+option(USE_CUDA "Enable CUDA support" ON)
+if(USE_CUDA)
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -allow-unsupported-compiler")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcudafe \"--diag_suppress=20012\"")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcudafe \"--diag_suppress=20014\"")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcudafe \"--diag_suppress=20015\"")
+    find_package(CUDAToolkit REQUIRED)
+    enable_language(CUDA)
+    set(CMAKE_CUDA_ARCHITECTURES 61)
+    include_directories(${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
+    add_compile_definitions(USE_CUDA)
+endif()
+
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 2)
+set(PROJECT_VERSION_MINOR 6)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")

@@ -31,207 +46,250 @@ 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}")
-
-include(uLibMacros)
-include(uLibDebugMacro)
-include(uLibTargetMacros)
-include(uLibGenerateRMake)
-
-
+message(STATUS "Project name = ${PROJECT_NAME}")
+message(STATUS "Package name = ${PACKAGE_NAME}")
+message(STATUS "Package version = ${PACKAGE_VERSION}")
+message(STATUS "Module path = ${CMAKE_MODULE_PATH}")

 ## GLOBALS ------------------------------------------------------------------ ##

-include(uLibCommon)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ") ## Add flags here ##
+# -- move to GnuInstallDirs
+# ref: https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
+set(INSTALL_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of header files (.../include)" )
+set(INSTALL_ETC_DIR ${CMAKE_INSTALL_SYSCONFDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of configuration files (.../etc)" )
+set(INSTALL_BIN_DIR ${CMAKE_INSTALL_BINDIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of executable files (.../bin)" )
+set(INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "Location of library files (.../lib)" )
+set(INSTALL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PACKAGE_NAME}
+    CACHE PATH "Location of cmake files (.../lib/cmake)" )   
+set(INSTALL_DATA_DIR ${CMAKE_INSTALL_DATADIR}/${PACKAGE_NAME}
+    CACHE PATH "Location of data files (.../share)" )

+
+
+
+set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)
+
+# this is used to be exported in build target 
+# ( to compile against build directory instead of install )
+set(ULIB_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+
+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} ${CMAKE_CXX_WARNING_OPTION}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
+
+# CTEST framework
+include(CTest)
 enable_testing()

+
 ## FIND PACKAGES ------------------------------------------------------------ ##

-include(uLibFindDependencies)
+set(Boost_USE_STATIC_LIBS OFF)
+set(Boost_USE_MULTITHREADED ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
+message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")

+find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
+
+find_package(Eigen3 CONFIG REQUIRED)
+get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+include_directories(${EIGEN3_INCLUDE_DIRS})
+
+find_package(ROOT CONFIG REQUIRED)
+include(${ROOT_USE_FILE})
+
+find_package(VTK REQUIRED)
+# include(${VTK_USE_FILE})
+
+find_package(pybind11 REQUIRED)
+
+
+option(CENTOS_SUPPORT "VTK definitions for CentOS" OFF)
+if(CENTOS_SUPPORT)
+    find_package(VTK CONFIG REQUIRED)
+    include(${VTK_USE_FILE})
+else()
+    find_package(VTK REQUIRED
+                     COMPONENTS CommonColor
+                                CommonCore
+                                FiltersCore
+                                FiltersModeling
+                                FiltersSources
+                                IOLegacy
+                                IOXML
+                                IOXMLParser
+                                ImagingCore
+                                InteractionStyle
+                                InteractionWidgets
+                                RenderingAnnotation
+                                RenderingContextOpenGL2
+                                RenderingCore
+                                RenderingFreeType
+                                RenderingGL2PSOpenGL2
+                                RenderingOpenGL2
+                                RenderingVolumeOpenGL2)
+endif()
+
+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 ${INSTALL_INC_DIR})

 ## ADD LIBRARIES SUBDIRECTORIES --------------------------------------------- ##

-## select modules ##
-set(ULIB_SELECTED_MODULES
-      ltk
-      Core
-      Math
-      Detectors
-      Root
-)
+include_directories(${PROJECT_BINARY_DIR})
+include_directories(${SRC_DIR})

 ## uLib_add_shared_library puts names there
 set(ULIB_SHARED_LIBRARIES)
+## select modules ##
+set(ULIB_SELECTED_MODULES)

-if(ULIB_USE_VTK)
- LIST(APPEND ULIB_SELECTED_MODULES Vtk)
-endif(ULIB_USE_VTK)
+include_directories(${SRC_DIR}/Core)
+add_subdirectory(${SRC_DIR}/Core)

-## this gets ulib modules into a variable ##
-function(uLib_modules result)
- 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}/Math)
+add_subdirectory(${SRC_DIR}/Math)

+include_directories(${SRC_DIR}/Detectors)
+add_subdirectory(${SRC_DIR}/Detectors)

-## ENTERING MODULES SUBDIRECTORIES ##
-message("/////////// SELECTED MODULES //////////////")
-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)
+include_directories(${SRC_DIR}/Root)
+add_subdirectory(${SRC_DIR}/Root)

-## SINGLE LIBRARY LINKING ## (work in progress ... )
-option(ULIB_SINGLELIBRARY "Link everything to a single library" OFF)
-if(ULIB_SINGLELIBRARY) 
-# set(modgrp)
-# foreach(module ${ULIB_SELECTED_MODULES})
-#  set(grpn srcgrp_${module})
-#  list(APPEND modgrp ${grpn})
-# endforeach(module)
-# add_library(${project_name} SHARED ${srcgrp_Core})
-endif(ULIB_SINGLELIBRARY)
+include_directories(${SRC_DIR}/Vtk)
+add_subdirectory(${SRC_DIR}/Vtk)
+
+add_subdirectory(${SRC_DIR}/Python)
+
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")
+
+## Documentation and packages
+
+#include(uLibGenerateDoc)

 ## UTILITIES ##
-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)
-
-
-
+#add_subdirectory("${SRC_DIR}/utils/make_recipe")


 ## INSTALLS AND EXPORTS ----------------------------------------------------- ##

-#export(PACKAGE uLib)
-export(PACKAGE ULIB)
-export(TARGETS ${ULIB_SHARED_LIBRARIES} ${ULIB_EXPORTED_TARGETS}
-       FILE "${PROJECT_BINARY_DIR}/uLibTargets.cmake"    )
-#export(TARGETS ${ULIB_EXPORTED_TARGETS}
-#       FILE "${PROJECT_BINARY_DIR}/uLibExeTargets.cmake" )
+#export(PACKAGE ULIB)
+#export(TARGETS ${ULIB_SHARED_LIBRARIES} ${ULIB_EXPORTED_TARGETS}
+#       FILE "${PROJECT_BINARY_DIR}/uLibTargets.cmake"    )


 # Create the FooBarConfig.cmake and FooBarConfigVersion files
-file(RELATIVE_PATH REL_INCLUDE_DIR "${PACKAGE_INSTALL_CMAKE_DIR}"
-   "${PACKAGE_INSTALL_INC_DIR}")
+# file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}"
+#    "${INSTALL_INC_DIR}")
+
 # ... for the build tree
-set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
-configure_file(uLibConfig.cmake.in
-  "${PROJECT_BINARY_DIR}/uLibConfig.cmake" @ONLY)
+#set(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}")
+#configure_file(uLibConfig.cmake.in 
+#               "${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)
+# [ removed for the configure_config_file ]
+# configure_file(uLibConfig.cmake.in
+#                "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+#                @ONLY)
+
 # ... for both
 configure_file(uLibConfigVersion.cmake.in
                "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake" @ONLY)

-# Install the FooBarConfig.cmake and FooBarConfigVersion.cmake
-install(FILES
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/uLibConfig.cmake"
+
+# from CMake 3.x configure file shall be created using a dedicated function
+# see: https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html
+#
+include(CMakePackageConfigHelpers)
+configure_package_config_file(uLibConfig.cmake.in
+                              "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
+                              INSTALL_DESTINATION ${INSTALL_CMAKE_DIR}
+                              PATH_VARS 
+                                INSTALL_LIB_DIR 
+                                INSTALL_INC_DIR 
+                                INSTALL_BIN_DIR 
+                                INSTALL_CMAKE_DIR 
+                                INSTALL_ETC_DIR 
+                                INSTALL_DATA_DIR
+                                ULIB_SOURCE_DIR
+                                ULIB_SHARED_LIBRARIES
+                              # NO_SET_AND_CHECK_MACRO
+                              # NO_CHECK_REQUIRED_COMPONENTS_MACRO
+                              )
+
+install(FILES "${PROJECT_BINARY_DIR}/uLibConfig.cmake"
              "${PROJECT_BINARY_DIR}/uLibConfigVersion.cmake"
-  DESTINATION "${PACKAGE_INSTALL_CMAKE_DIR}" COMPONENT dev)
-
-# Install the export set for use with the install-tree
-install(EXPORT "${PROJECT_NAME}Targets" DESTINATION
-  "${PACKAGE_INSTALL_CMAKE_DIR}" COMPONENT dev)
-
-install(FILES ${PROJECT_SOURCE_DIR}/ulib.h DESTINATION ${PACKAGE_INSTALL_INC_DIR})
+        DESTINATION "${INSTALL_CMAKE_DIR}"
+        COMPONENT dev)


-
-## 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
+# this is a special target file for the build tree
+# it is used also to identify if we are using a build direcory
+# to link a project against uLib. see: uLibConfig.cmake ( IF )
+export (TARGETS ${ULIB_SHARED_LIBRARIES}
+        FILE "${PROJECT_BINARY_DIR}/uLibTargets-build.cmake"
+        # NAMESPACE "uLib::"
 )        

-
-
-
+# Install the export set for use with the install-tree
+install(EXPORT "uLibTargets"
+        FILE "uLibTargets.cmake"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
+        COMPONENT dev)

--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -0,0 +1,16 @@
+{
+    "version": 8,
+    "configurePresets": [
+        {
+            "name": "andrea",
+            "displayName": "Custom configure preset",
+            "description": "Sets Ninja generator, build and install directory",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
+            }
+        }
+    ]
+}
--- a/CMakeUserPresets.json
+++ b/CMakeUserPresets.json
@@ -0,0 +1,9 @@
+{
+    "version": 4,
+    "vendor": {
+        "conan": {}
+    },
+    "include": [
+        "build/CMakePresets.json"
+    ]
+}
--- a/35
+++ b/35
@@ -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} ';'"
+            }
+
+        }
+
+    }
+
+}
--- a/README.md
+++ b/README.md
@@ -0,0 +1,70 @@
+# 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
+
+## Build Instructions
+
+This project relies on `conan` (v2) for dependency management (Eigen3, Boost) and `cmake` for configuration. VTK is provided through the micromamba/conda-forge environment.
+
+### Prerequisites
+
+This project requires a `conda` or `micromamba` environment containing the necessary global tools like **ROOT**, **VTK**, and **Conan** (v2). We provide a `condaenv.yml` file to quickly build this environment.
+
+#### Installing Micromamba (Optional)
+
+If you do not have `conda` installed, `micromamba` is a fast and lightweight alternative. You can install it on Linux via:
+
+```bash
+"${SHELL}" <(curl -L micro.mamba.pm/install.sh)
+```
+
+#### Creating the Environment
+
+You can create and activate the environment using either `micromamba` or `conda`.
+
+**Using Micromamba:**
+```bash
+micromamba env create -f condaenv.yml
+micromamba activate mutom
+```
+
+**Using Conda:**
+```bash
+conda env create -f condaenv.yml
+conda activate mutom
+```
+
+### Configure and Build
+
+1. **Configure Conan profile (if you haven't yet on your machine):**
+```bash
+conan profile detect
+```
+
+2. **Install Conan dependencies:**
+```bash
+conan install . --output-folder=build --build=missing
+```
+
+3. **Configure the project with CMake:**
+```bash
+cmake --preset conan-release
+```
+*(Alternatively: `cd build && cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release`)*
+
+4. **Build the project:**
+```bash
+cmake --build build -j10
+```
+
+### Make python package
+
+```bash
+micromamba run -n mutom env USE_CUDA=ON poetry install
+```
+
--- a/build.log
+++ b/build.log
@@ -0,0 +1,36 @@
+make: Entering directory '/home/rigoni/devel/cmt/ulib/build'
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxImage.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/TriangleMesh.cpp.o
+[ 30%] Building CXX object src/Core/CMakeFiles/mutomCore.dir/Options.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Dense.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredGrid.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxRaytracer.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredData.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured2DGrid.cpp.o
+[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured4DGrid.cpp.o
+[ 33%] Linking CXX shared library libmutomCore.so
+[ 33%] Built target mutomCore
+[ 36%] Linking CXX shared library libmutomMath.so
+[ 36%] Built target mutomMath
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkContainerBox.cpp.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkInterface.cxx.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkStructuredGrid.cpp.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkMuonScatter.cxx.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkViewer.cpp.o
+[ 63%] Generating mutomRootDict.cxx, libmutomRootDict_rdict.pcm, libmutomRootDict.rootmap
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxImage.cpp.o
+[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxRaytracerRepresentation.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorSkinHit.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorHit.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMCTrack.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorInfo.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/RootMuonScatter.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorPrimaryVertex.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMuDetDIGI.cpp.o
+[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/SkinDetectorWriter.cpp.o
+[ 93%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/mutomRootDict.cxx.o
+[ 96%] Linking CXX shared library libmutomVtk.so
+[ 96%] Built target mutomVtk
+[100%] Linking CXX shared library libmutomRoot.so
+[100%] Built target mutomRoot
+make: Leaving directory '/home/rigoni/devel/cmt/ulib/build'
--- a/build_python.py
+++ b/build_python.py
@@ -0,0 +1,54 @@
+import os
+import subprocess
+import sys
+import shutil
+
+def build(setup_kwargs):
+    """
+    Build the C++ extension using CMake.
+    This function is called by poetry-core during the build process.
+    The binary is placed directly inside the uLib directory in src/Python.
+    """
+    # Root of the whole project where this build_extension.py is located
+    project_root = os.path.abspath(os.path.dirname(__file__))
+    
+    # Where the extension should go
+    package_dir = os.path.join(project_root, "src/Python/uLib")
+    
+    # Ensure package directory exists
+    os.makedirs(package_dir, exist_ok=True)
+    
+    # Temporary build directory
+    build_temp = os.path.join(project_root, "build_python")
+    os.makedirs(build_temp, exist_ok=True)
+
+    print(f"--- Running CMake build in {build_temp} ---")
+    print(f"Project root: {project_root}")
+    print(f"Target binary dir: {package_dir}")
+
+    # Determine if CUDA should be enabled
+    use_cuda = os.environ.get("USE_CUDA", "OFF").upper()
+    if use_cuda in ["ON", "1", "TRUE", "YES"]:
+        use_cuda = "ON"
+    else:
+        use_cuda = "OFF"
+    
+    # CMake configuration
+    cmake_args = [
+        f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={package_dir}",
+        f"-DPYTHON_EXECUTABLE={sys.executable}",
+        "-DCMAKE_BUILD_TYPE=Release",
+        f"-DUSE_CUDA={use_cuda}", 
+        "-G", "Unix Makefiles",
+    ]
+
+    # Use micromamba to ensure Boost and VTK are found during the build
+    subprocess.check_call(["cmake", project_root] + cmake_args, cwd=build_temp)
+    subprocess.check_call(["cmake", "--build", ".", "--parallel", "--target", "uLib_python"], cwd=build_temp)
+    
+    # Ensure the package is found by poetry during the wheel creation process.
+    # Return setup_kwargs for poetry-core.
+    return setup_kwargs
+
+if __name__ == "__main__":
+    build({})
--- a/conanfile.txt
+++ b/conanfile.txt
@@ -0,0 +1,8 @@
+[requires]
+eigen/3.4.0
+boost/1.83.0
+pybind11/3.0.2
+
+[generators]
+CMakeDeps
+CMakeToolchain
--- a/condaenv.yml
+++ b/condaenv.yml
@@ -0,0 +1,10 @@
+name: mutom
+channels:
+  - conda-forge
+dependencies:
+  - compiler-rt
+  - make
+  - cmake
+  - conan
+  - root
+  - vtk
--- a/docs/assets/css/extensions/tabbed.css
+++ b/docs/assets/css/extensions/tabbed.css
@@ -0,0 +1,41 @@
+.tabbed-set {
+  display: flex;
+  position: relative;
+  flex-wrap: wrap;
+}
+
+.tabbed-set .highlight {
+  background: #ddd;
+}
+
+.tabbed-set .tabbed-content {
+  display: none;
+  order: 99;
+  width: 100%;
+}
+
+.tabbed-set label {
+  width: auto;
+  margin: 0 0.5em;
+  padding: 0.25em;
+  font-size: 120%;
+  cursor: pointer;
+  color: #ffffff !important;
+}
+
+.tabbed-set input {
+  position: absolute;
+  opacity: 0;
+}
+
+.tabbed-set input:nth-child(n+1) {
+  color: #333333;
+}
+
+.tabbed-set input:nth-child(n+1):checked + label {
+    color: cyan !important;
+}
+
+.tabbed-set input:nth-child(n+1):checked + label + .tabbed-content {
+    display: block;
+}
--- a/docs/assets/css/extra.css
+++ b/docs/assets/css/extra.css
@@ -0,0 +1,17 @@
+@import "extensions/tabbed.css";
+
+.md-grid {
+    max-width: 100%;
+}
+
+.md-main__inner {
+    margin-top: 0;
+    padding-top: 0;
+}
+
+.md-sidebar--secondary {
+    right: 1.5rem;
+    top: 4.8rem;
+    transform: none;
+    width: 18rem;
+}
--- a/docs/docker/Dockerfile
+++ b/docs/docker/Dockerfile
@@ -0,0 +1,30 @@
+# Stage 1: Build the static site using MkDocs
+FROM python:3.9-slim-buster as builder
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the requirements file
+COPY requirements.txt .
+
+# Install the Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application files
+COPY ../.. .
+
+# Build the MkDocs site
+RUN mkdocs build
+
+
+# Stage 2: Serve the static files with Nginx
+FROM nginx:alpine
+
+# Copy the built site from the builder stage
+COPY --from=builder /app/site /usr/share/nginx/html
+
+# Expose port 80 for the web server
+EXPOSE 80
+
+# Command to run Nginx in the foreground
+CMD ["nginx", "-g", "daemon off;"]
--- a/docs/docker/Dockerfile.dev
+++ b/docs/docker/Dockerfile.dev
@@ -0,0 +1,14 @@
+# Dockerfile for development with live-reloading
+FROM python:3.9-slim-buster
+
+WORKDIR /app
+
+# Copy and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the port MkDocs serve will run on
+EXPOSE 8000
+
+# Command to run the development server
+CMD ["mkdocs", "serve", "--dev-addr", "0.0.0.0:8000"]
--- a/docs/docker/docker-compose.yml
+++ b/docs/docker/docker-compose.yml
@@ -0,0 +1,13 @@
+version: '3.8'
+
+services:
+  mkdocs:
+    build:
+      context: .
+      dockerfile: Dockerfile.dev
+    ports:
+      - "8000:8000"
+    volumes:
+      - ../..:/app
+    environment:
+      - GIT_DISCOVERY_ACROSS_FILESYSTEM=1 
--- a/docs/docker/requirements.txt
+++ b/docs/docker/requirements.txt
@@ -0,0 +1,17 @@
+# ------------------------------------------------------------------
+# MkDocs runtime dependencies for the docs Docker image
+# ------------------------------------------------------------------
+
+# Core: theme (provides mkdocs itself as a transitive dep)
+mkdocs-material==9.7.1
+
+# pymdownx.* extensions used in mkdocs.yml:
+#   arithmatex, highlight, superfences, tabbed, details, blocks.caption
+# (also a hard dep of mkdocs-material, pinned here for reproducibility)
+pymdown-extensions>=10.0
+
+# Markdown math rendering support (arithmatex generic mode)
+# JS side is loaded via CDN (polyfill.io + MathJax), no extra Python pkg needed
+
+# Optional: PDF export plugin (exporter: block, currently commented out in mkdocs.yml)
+mkdocs-exporter
--- a/docs/docker/runtime.txt
+++ b/docs/docker/runtime.txt
@@ -0,0 +1 @@
+3.7
--- a/docs/index.md
+++ b/docs/index.md
@@ -0,0 +1,63 @@
+# uLib
+
+[![DOI](https://zenodo.org/badge/36926725.svg)](https://zenodo.org/badge/latestdoi/36926725)
+
+**uLib** is the base toolkit library for the **CMT (Cosmic Muon Tomography)** project, developed at the University of Padova and INFN Sezione di Padova, Italy.
+
+It provides:
+
+- **Core** – object model, timers, configuration, UUID utilities.
+- **Math** – linear algebra (Eigen3), structured grids, voxel images, ray-tracing, image filters.
+- **Python bindings** – full pybind11 interface for scripting and analysis workflows.
+- Optional **CUDA** acceleration for voxel filtering (transparent RAM ↔ VRAM management).
+
+---
+
+## Quick Start
+
+=== "Users (pip / poetry)"
+    ```bash
+    # Activate your conda/micromamba environment first
+    micromamba activate mutom
+
+    poetry install            # CPU build
+    USE_CUDA=ON poetry install # GPU build
+    ```
+
+=== "Developers (CMake)"
+    ```bash
+    conan install . --output-folder=build --build=missing
+    cmake --preset conan-release
+    cmake --build build --target uLib_python -j$(nproc)
+
+    export PYTHONPATH="$(pwd)/build/src/Python:$(pwd)/src/Python"
+    ```
+
+Then in Python:
+
+```python
+import uLib
+
+# Core
+timer = uLib.Core.Timer()
+timer.Start()
+
+# Math
+grid = uLib.Math.StructuredGrid([10, 10, 10])
+grid.SetSpacing([1.0, 1.0, 1.0])
+
+img = uLib.Math.VoxImage([10, 10, 10])
+img.SetValue(0, 3.14)
+print(img.GetValue(0))
+```
+
+---
+
+## Documentation Sections
+
+| Section | Description |
+|---|---|
+| [Python – Installation](python/installation.md) | Environment setup, user install, developer build |
+| [Python – API Usage](python/usage.md) | Full API reference with examples |
+| [Python – Developer Guide](python/developer_guide.md) | Adding bindings, running tests, build details |
+| [C++ Build – Usage & CUDA](usage/usage.md) | CMake build, CUDA configuration |
--- a/docs/python/developer_guide.md
+++ b/docs/python/developer_guide.md
@@ -0,0 +1,179 @@
+# Developer Guide – Python Bindings
+
+This guide is aimed at contributors who want to extend or modify the Python bindings for `uLib`.
+
+---
+
+## Repository Layout
+
+```
+ulib/
+├── src/
+│   └── Python/
+│       ├── module.cpp               # pybind11 module entry point
+│       ├── core_bindings.cpp        # uLib::Core bindings
+│       ├── math_bindings.cpp        # uLib::Math bindings
+│       ├── math_filters_bindings.cpp# VoxImageFilter bindings
+│       ├── CMakeLists.txt           # builds uLib_python shared lib
+│       ├── testing/                 # Python unit tests
+│       │   ├── pybind_test.py
+│       │   ├── core_pybind_test.py
+│       │   ├── math_pybind_test.py
+│       │   └── math_filters_test.py
+│       └── uLib/                    # Python package (uLib_python.so lands here)
+│           └── __init__.py
+├── build_python.py                  # poetry build hook (calls CMake)
+├── pyproject.toml                   # poetry metadata
+└── condaenv.yml                     # conda/micromamba environment
+```
+
+---
+
+## Adding a New Binding
+
+All bindings live in the four source files listed above. The module entry point `module.cpp` calls `init_core()`, `init_math()`, and `init_math_filters()` in order.
+
+### 1. Pick (or create) the right binding file
+
+| C++ header location | Binding file |
+|---|---|
+| `src/Core/` | `core_bindings.cpp` |
+| `src/Math/` (geometry, grids, VoxImage) | `math_bindings.cpp` |
+| `src/Math/VoxImageFilter*.hpp` | `math_filters_bindings.cpp` |
+
+### 2. Add the `#include` directive
+
+```cpp
+// math_bindings.cpp
+#include "Math/MyNewClass.h"
+```
+
+### 3. Write the pybind11 binding inside the appropriate `init_*` function
+
+```cpp
+void init_math(py::module_ &m) {
+    // ... existing bindings ...
+
+    py::class_<MyNewClass>(m, "MyNewClass")
+        .def(py::init<>())
+        .def("MyMethod",  &MyNewClass::MyMethod)
+        .def("AnotherMethod", &MyNewClass::AnotherMethod,
+             py::arg("x"), py::arg("y") = 0.0f);
+}
+```
+
+### 4. Rebuild only the Python target
+
+```bash
+cmake --build build --target uLib_python -j$(nproc)
+```
+
+### 5. Write a Python test
+
+Add a new test class to the relevant test file (or create a new one under `src/Python/testing/`):
+
+```python
+# src/Python/testing/math_pybind_test.py
+class TestMyNewClass(unittest.TestCase):
+    def test_basic(self):
+        obj = uLib.Math.MyNewClass()
+        result = obj.MyMethod()
+        self.assertAlmostEqual(result, expected_value)
+```
+
+Register the test in `src/Python/CMakeLists.txt` if you add a new file:
+
+```cmake
+add_test(NAME pybind_my_new
+         COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testing/my_new_test.py)
+set_tests_properties(pybind_my_new PROPERTIES
+    ENVIRONMENT "PYTHONPATH=$<TARGET_FILE_DIR:uLib_python>:${PROJECT_SOURCE_DIR}/src/Python")
+```
+
+---
+
+## Build System Details
+
+### CMakeLists.txt (`src/Python/`)
+
+`pybind11_add_module` compiles the shared library `uLib_python` and links it against the C++ static/shared libraries `uLibCore` and `uLibMath`. The install target copies the `.so` into the standard library directory.
+
+```cmake
+pybind11_add_module(uLib_python
+    module.cpp core_bindings.cpp math_bindings.cpp math_filters_bindings.cpp)
+
+target_link_libraries(uLib_python PRIVATE uLibCore uLibMath)
+```
+
+### poetry / build_python.py
+
+`pyproject.toml` declares `build_python.py` as the custom build hook. When `poetry install` or `poetry build` is invoked it:
+
+1. Calls `cmake <root> -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=<pkg_dir> ...` in `build_python/`.
+2. Builds only the `uLib_python` target.
+3. The resulting `.so` is placed inside `src/Python/uLib/` so it is picked up by Poetry as a package data file.
+
+The `USE_CUDA` environment variable gates CUDA support at build time:
+
+```bash
+USE_CUDA=ON poetry install   # with CUDA
+USE_CUDA=OFF poetry install  # CPU only (default)
+```
+
+---
+
+## Running All Tests
+
+```bash
+# From the repository root, with PYTHONPATH set:
+export PYTHONPATH="$(pwd)/build/src/Python:$(pwd)/src/Python"
+
+python -m pytest src/Python/testing/ -v
+```
+
+Or through CMake's test runner (after building the full project):
+
+```bash
+cd build
+ctest --output-on-failure -R pybind
+```
+
+Expected output (all passing):
+
+```
+    Start 1: pybind_general
+1/4 Test #1: pybind_general .............   Passed
+    Start 2: pybind_core
+2/4 Test #2: pybind_core ................   Passed
+    Start 3: pybind_math
+3/4 Test #3: pybind_math ................   Passed
+    Start 4: pybind_math_filters
+4/4 Test #4: pybind_math_filters ........   Passed
+```
+
+---
+
+## Memory Management Notes
+
+`uLib::Vector<T>` has explicit GPU memory management. When wrapping methods that return references to internal data, use `py::return_value_policy::reference_internal` to avoid dangling references:
+
+```cpp
+.def("Data", &VoxImage<Voxel>::Data,
+     py::return_value_policy::reference_internal)
+```
+
+For objects held by `std::unique_ptr` without Python-side deletion, use `py::nodelete`:
+
+```cpp
+py::class_<Abstract::VoxImageFilter,
+           std::unique_ptr<Abstract::VoxImageFilter, py::nodelete>>(m, "AbstractVoxImageFilter")
+```
+
+---
+
+## Useful References
+
+- [pybind11 documentation](https://pybind11.readthedocs.io)
+- [pybind11 – STL containers](https://pybind11.readthedocs.io/en/stable/advanced/cast/stl.html)
+- [pybind11 – Eigen integration](https://pybind11.readthedocs.io/en/stable/advanced/cast/eigen.html)
+- [CMake – pybind11 integration](https://pybind11.readthedocs.io/en/stable/compiling.html)
--- a/docs/python/installation.md
+++ b/docs/python/installation.md
@@ -0,0 +1,146 @@
+# Python Installation
+
+The `uLib` Python package exposes the Core and Math C++ libraries via [pybind11](https://pybind11.readthedocs.io) bindings. There are two ways to install it: as an **end user** (pre-built wheel / pip) or as a **developer** (editable build from source).
+
+---
+
+## Prerequisites
+
+`uLib` depends on native C++ libraries that must be compiled. Ensure the following are available in your environment before installing:
+
+| Dependency | Minimum version | Notes |
+|---|---|---|
+| Python | 3.9 | |
+| CMake | 3.12 | |
+| pybind11 | 2.6.0 | |
+| Conan | 2.x | for Eigen3 / Boost |
+| micromamba / conda | any | recommended – provides ROOT, VTK |
+
+### Creating the `mutom` Conda/Micromamba Environment
+
+A ready-to-use environment definition is provided as `condaenv.yml` at the repository root.
+
+=== "Micromamba"
+    ```bash
+    micromamba env create -f condaenv.yml
+    micromamba activate mutom
+    ```
+
+=== "Conda"
+    ```bash
+    conda env create -f condaenv.yml
+    conda activate mutom
+    ```
+
+The environment installs CMake, Conan, ROOT, VTK, and the compiler toolchain.
+
+> **CUDA (optional)**  
+> If you want GPU-accelerated voxel filtering, you also need NVCC inside the environment:
+> ```bash
+> micromamba install cuda-nvcc -c conda-forge
+> ```
+
+---
+
+## User Installation (wheel / pip)
+
+Once the native dependencies are present in your environment, install the package with Poetry or pip:
+
+```bash
+# Activate your environment first
+micromamba activate mutom
+
+# Build and install (CUDA disabled by default)
+poetry install
+
+# Build and install with CUDA support
+USE_CUDA=ON poetry install
+```
+
+After installation the module is importable from anywhere in the environment:
+
+```python
+import uLib
+print(dir(uLib.Core))
+print(dir(uLib.Math))
+```
+
+---
+
+## Developer Installation (editable / in-tree build)
+
+For development you typically want to skip the packaging layer and work directly against the CMake build tree.
+
+### Step 1 – Install Conan dependencies
+
+```bash
+conan profile detect          # first time only
+conan install . --output-folder=build --build=missing
+```
+
+### Step 2 – Configure and build
+
+```bash
+# Standard release build
+cmake --preset conan-release
+
+# …or manually
+cmake -B build \
+      -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DUSE_CUDA=OFF          # set to ON when a GPU is available
+
+cmake --build build --target uLib_python -j$(nproc)
+```
+
+The shared library (`uLib_python*.so`) is written to `build/src/Python/`.
+
+### Step 3 – Make the module importable
+
+Point `PYTHONPATH` at the build output **and** the Python source directory (the latter carries the `uLib/__init__.py` that stitches sub-modules together):
+
+```bash
+export PYTHONPATH="$(pwd)/build/src/Python:$(pwd)/src/Python:$PYTHONPATH"
+python -c "import uLib; print(uLib.__version__)"
+```
+
+Or, for a one-shot check:
+
+```bash
+PYTHONPATH="build/src/Python:src/Python" python src/Python/testing/pybind_test.py
+```
+
+### Step 4 – Run the tests
+
+CMake registers the Python tests alongside the C++ ones; use `ctest` from the build directory:
+
+```bash
+cd build
+ctest --output-on-failure -R pybind
+```
+
+Individual test scripts can also be run directly once `PYTHONPATH` is set:
+
+```bash
+python src/Python/testing/core_pybind_test.py
+python src/Python/testing/math_pybind_test.py
+python src/Python/testing/math_filters_test.py
+```
+
+---
+
+## Verifying the Installation
+
+```python
+import uLib
+
+# Core module
+obj    = uLib.Core.Object()
+timer  = uLib.Core.Timer()
+timer.Start()
+elapsed = timer.StopWatch()   # float, seconds
+
+# Math module
+v3 = uLib.Math.Vector3f([1.0, 0.0, 0.0])
+print(v3[0])  # 1.0
+```
--- a/docs/python/usage.md
+++ b/docs/python/usage.md
@@ -0,0 +1,373 @@
+# Python API Usage
+
+The `uLib` Python package is split into two sub-modules mirroring the C++ library:
+
+| Sub-module | Contents |
+|---|---|
+| `uLib.Core` | Low-level utilities: `Object`, `Timer`, `Options`, `TypeRegister` |
+| `uLib.Math` | Geometry, grids, voxel images, ray-tracing, image filters |
+
+```python
+import uLib
+# Sub-modules are accessible as attributes
+uLib.Core   # core utilities
+uLib.Math   # mathematical structures
+```
+
+---
+
+## uLib.Core
+
+### Object
+
+Base class for uLib objects; exposed to Python for type-hierarchy purposes.
+
+```python
+obj = uLib.Core.Object()
+copy = obj.DeepCopy()
+```
+
+### Timer
+
+Precision wall-clock timer.
+
+```python
+import time
+timer = uLib.Core.Timer()
+timer.Start()
+time.sleep(0.5)
+elapsed = timer.StopWatch()   # returns elapsed seconds as float
+print(f"Elapsed: {elapsed:.3f} s")
+```
+
+### Options
+
+Wraps Boost.ProgramOptions for INI-style configuration files.
+
+```python
+opt = uLib.Core.Options("My Program")
+opt.parse_config_file("config.ini")   # load settings
+n = opt.count("my_key")               # check if key exists
+opt.save_config_file("out.ini")
+```
+
+---
+
+## uLib.Math – Linear Algebra
+
+The math module exposes Eigen3 vectors and matrices as well-typed Python objects with NumPy interoperability.
+
+### Fixed-size Vectors
+
+```python
+import numpy as np
+import uLib
+
+# Construct from list
+v3 = uLib.Math.Vector3f([1.0, 2.0, 3.0])
+print(v3[0], v3[1], v3[2])   # 1.0 2.0 3.0
+
+# Construct from NumPy array
+arr = np.array([4.0, 5.0, 6.0], dtype=np.float32)
+v3b = uLib.Math.Vector3f(arr)
+
+# Zero-initialise
+v4d = uLib.Math.Vector4d()    # all zeros
+
+# Available types
+# Vector1f / 2f / 3f / 4f  (float32)
+# Vector1d / 2d / 3d / 4d  (float64)
+# Vector1i / 2i / 3i / 4i  (int32)
+```
+
+### Fixed-size Matrices
+
+```python
+# 2-by-2 float matrix
+m2f = uLib.Math.Matrix2f()
+m2f[0, 0] = 1;  m2f[0, 1] = 2
+m2f[1, 0] = 3;  m2f[1, 1] = 4
+
+# From list (row-major)
+m4f = uLib.Math.Matrix4f([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1])
+
+# From NumPy (2-D array)
+mat = np.eye(3, dtype=np.float32)
+m3f = uLib.Math.Matrix3f(mat)
+
+# Dynamic matrices
+mXf = uLib.Math.MatrixXf(4, 4)   # 4×4 float, zeros
+```
+
+### Homogeneous Types
+
+```python
+# HPoint3f – a 3-D point in homogeneous coordinates (w = 1)
+p = uLib.Math.HPoint3f(1.0, 2.0, 3.0)
+
+# HVector3f – a free vector (w = 0)
+v = uLib.Math.HVector3f(0.0, 1.0, 0.0)
+
+# HLine3f – a parametric ray
+line = uLib.Math.HLine3f()
+line.origin    = uLib.Math.HPoint3f(0, 0, 0)
+line.direction = uLib.Math.HVector3f(0, 0, 1)
+```
+
+---
+
+## uLib.Math – Transforms and Geometry
+
+### AffineTransform
+
+A rigid-body / affine transform stored as a 4×4 matrix.
+
+```python
+tf = uLib.Math.AffineTransform()
+
+tf.SetPosition([1.0, 0.0, 0.0])   # translate
+tf.Translate([0.0, 1.0, 0.0])     # cumulative translate
+tf.Scale([2.0, 2.0, 2.0])         # uniform scale
+tf.Rotate(uLib.Math.Vector3f([0, 0, 3.14159]))  # Euler angles (rad)
+
+mat4 = tf.GetWorldMatrix()   # 4×4 matrix
+pos  = tf.GetPosition()      # Vector3f
+```
+
+### Geometry
+
+Inherits `AffineTransform`; converts points between world and local frames.
+
+```python
+geo = uLib.Math.Geometry()
+geo.SetPosition([1.0, 1.0, 1.0])
+
+world_pt = uLib.Math.Vector4f([2.0, 3.0, 2.0, 1.0])
+local_pt = geo.GetLocalPoint(world_pt)
+back     = geo.GetWorldPoint(local_pt)
+# back ≈ [2, 3, 2, 1]
+```
+
+### ContainerBox
+
+An axis-aligned bounding box with an associated transform.
+
+```python
+box = uLib.Math.ContainerBox()
+box.SetOrigin([-1.0, -1.0, -1.0])
+box.SetSize([2.0, 2.0, 2.0])
+print(box.GetSize())    # [2, 2, 2]
+```
+
+---
+
+## uLib.Math – Structured Grids
+
+### StructuredGrid (3-D)
+
+A 3-D voxel grid (origin, spacing, and integer dimensions).
+
+```python
+dims = uLib.Math.Vector3i([10, 10, 10])
+grid = uLib.Math.StructuredGrid(dims)
+grid.SetSpacing([1.0, 1.0, 1.0])
+grid.SetOrigin([0.0, 0.0, 0.0])
+
+print(grid.GetSpacing())          # [1, 1, 1]
+print(grid.IsInsideBounds([5, 5, 5, 1]))  # True
+idx = grid.Find([2.5, 2.5, 2.5]) # returns grid cell index
+```
+
+### Structured2DGrid / Structured4DGrid
+
+```python
+grid2d = uLib.Math.Structured2DGrid()
+grid2d.SetDims([100, 100])
+grid2d.SetPhysicalSpace([0, 0], [1, 1])
+print(grid2d.GetSpacing())
+```
+
+---
+
+## uLib.Math – VoxImage
+
+`VoxImage` is a 3-D voxel volume where each cell stores a `Voxel` ( `.Value` + `.Count`).
+
+```python
+dims = uLib.Math.Vector3i([20, 20, 20])
+img  = uLib.Math.VoxImage(dims)
+img.SetSpacing([0.5, 0.5, 0.5])
+
+# Access by linear index
+img.SetValue(0, 42.0)
+print(img.GetValue(0))    # 42.0
+
+# Access by 3-D index
+img.SetValue(uLib.Math.Vector3i([1, 1, 1]), 7.5)
+print(img.GetValue(uLib.Math.Vector3i([1, 1, 1])))  # 7.5
+
+# Clipping / masking helpers
+cropped = img.clipImage(uLib.Math.Vector3i([2, 2, 2]),
+                        uLib.Math.Vector3i([18, 18, 18]))
+masked  = img.maskImage(0.0, 100.0, 0.0)   # mask outside [0, 100]
+
+# I/O
+img.ExportToVti("output.vti")
+img.ImportFromVti("output.vti")
+```
+
+### Voxel (element type)
+
+```python
+vox = uLib.Math.Voxel()
+vox.Value = 1.5
+vox.Count = 3
+
+data = img.Data()        # returns the underlying Vector_Voxel
+vox0 = data[0]
+print(vox0.Value, vox0.Count)
+```
+
+---
+
+## uLib.Math – VoxRaytracer
+
+Performs ray-tracing through a `StructuredGrid` and returns per-voxel chord lengths.
+
+```python
+import numpy as np
+import uLib
+
+grid = uLib.Math.StructuredGrid([10, 10, 10])
+grid.SetSpacing([1.0, 1.0, 1.0])
+grid.SetOrigin([0.0, 0.0, 0.0])
+
+rt = uLib.Math.VoxRaytracer(grid)
+
+# Trace a ray between two homogeneous points (x, y, z, w=1)
+p1 = np.array([0.5, 0.5, -1.0, 1.0], dtype=np.float32)
+p2 = np.array([0.5, 0.5, 11.0, 1.0], dtype=np.float32)
+result = rt.TraceBetweenPoints(p1, p2)
+
+print("Voxels crossed:", result.Count())
+print("Total length  :", result.TotalLength())
+
+elements = result.Data()
+for i in range(result.Count()):
+    print(f"  vox_id={elements[i].vox_id}  L={elements[i].L:.4f}")
+```
+
+---
+
+## uLib.Math – Image Filters
+
+All filters share the same interface: construct with a kernel size, attach a `VoxImage`, optionally set parameters, then call `.Run()`.
+
+```python
+import uLib
+
+dims = uLib.Math.Vector3i([10, 10, 10])
+img  = uLib.Math.VoxImage(dims)
+for i in range(10**3):
+    img.SetValue(i, float(i))
+
+kernel_dims = uLib.Math.Vector3i([3, 3, 3])
+```
+
+### Linear (Gaussian / Box) Filter
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmLinear(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)   # uniform box kernel, length = product of dims
+filt.Run()
+```
+
+### ABTrim Filter
+
+Applies alpha-beta trimming to remove outliers before averaging.
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmAbtrim(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.SetABTrim(2, 2)    # trim 2 low and 2 high values
+filt.Run()
+```
+
+### Bilateral Filter
+
+Edge-preserving smoothing controlled by a spatial sigma (from the kernel shape) and an intensity sigma.
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmBilateral(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.SetIntensitySigma(0.3)
+filt.Run()
+```
+
+### Threshold Filter
+
+Zeros voxels below a threshold.
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmThreshold(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.SetThreshold(0.5)
+filt.Run()
+```
+
+### Median Filter
+
+```python
+filt = uLib.Math.VoxFilterAlgorithmMedian(kernel_dims)
+filt.SetImage(img)
+filt.SetKernelNumericXZY([1.0] * 27)
+filt.Run()
+```
+
+---
+
+## uLib.Math – Accumulators
+
+Accumulators collect scalar samples and return a summary statistic.
+
+```python
+# Arithmetic mean
+acc = uLib.Math.Accumulator_Mean_f()
+acc(10.0)
+acc(20.0)
+mean = acc()       # 15.0
+
+# Alpha-beta trimmed mean
+acc2 = uLib.Math.Accumulator_ABTrim_f()
+acc2.SetABTrim(0.1, 0.1)   # trim bottom 10 % and top 10 %
+acc2 += 1.0
+acc2 += 9999.0             # outlier
+acc2 += 5.0
+result = acc2()            # trimmed mean ≈ 3.0
+```
+
+---
+
+## Dynamic Vectors (`uLib.Math.Vector_*`)
+
+Typed dynamic arrays backed by `uLib::Vector<T>` with optional CUDA memory management.
+
+```python
+# Integer vector
+vi = uLib.Math.Vector_i()
+vi.append(1); vi.append(2); vi.append(3)
+print(len(vi), vi[0])
+
+# Float vector with CUDA management
+vf = uLib.Math.Vector_f()
+vf.append(1.5)
+vf.MoveToVRAM()   # copy to GPU (no-op when CUDA is absent)
+vf.MoveToRAM()    # copy back to CPU
+
+# Other types: Vector_ui, Vector_l, Vector_ul, Vector_d
+# Compound element types: Vector_Vector3f, Vector_Vector4f, Vector_Voxel …
+```
--- a/docs/usage/usage.md
+++ b/docs/usage/usage.md
@@ -0,0 +1,60 @@
+# Usage and Installation Guide
+
+## Requirements
+
+### Compiling with CUDA Support
+
+The library supports running VoxImage filtering operations directly on CUDA cores via transparent RAM/VRAM memory transfers.
+
+By default, the `CMakeLists.txt` build system sets `USE_CUDA=ON` and will attempt to locate `nvcc` and the NVIDIA CUDA Toolkit. If the toolkit is missing, `CMake` will fail unless you explicitly configure the project with `-DUSE_CUDA=OFF`.
+
+### 1. Installing CUDA Environment via Micromamba
+
+If you are developing inside an isolated Conda/Micromamba environment (e.g., `mutom`), you can inject the CUDA compilers directly into your environment rather than relying on global system dependencies:
+
+```bash
+# Add the conda-forge channel if not already available
+micromamba config append channels conda-forge
+
+# Install nvcc and the necessary CUDA toolkit components
+micromamba install cuda-nvcc
+```
+
+Verify your installation:
+
+```bash
+nvcc --version
+```
+
+### 2. Building the Project
+
+Configure and compile the project using standard CMake flows:
+
+```bash
+mkdir -p build && cd build
+
+# Configure CMake
+# (Optional) Explicitly toggle CUDA: cmake -DUSE_CUDA=ON ..
+cmake ..
+
+# Compile the project and tests
+make -j $(nproc)
+```
+
+### 3. Validating CUDA Support
+
+You can verify that the CUDA kernels are launching correctly and allocating device memory through `DataAllocator` by running the mathematical unit tests.
+
+```bash
+# From the build directory
+./src/Math/testing/VoxImageFilterTest
+
+# Output should show:
+# "Data correctly stayed in VRAM after CUDA execution!"
+```
+
+## How It Works Under The Hood
+
+The `DataAllocator<T>` container automatically wraps memory allocations to transparently map to CPU RAM, or GPU VRAM. Standard iteration automatically pulls data backwards using implicit `MoveToRAM()` calls. 
+
+Filters using `#ifdef USE_CUDA` explicitly dictate `<buffer>.MoveToVRAM()` allocating directly on device bounds seamlessly. Fallbacks to Host compute iterations handle themselves automatically. Chaining specific filters together safely chains continuous VRAM operations avoiding costly Host copies in between iterations.
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -0,0 +1,561 @@
+# site_name: uLib Documentation
+# site_description: CMT Cosmic Muon Tomography – uLib toolkit
+# site_author: Andrea Rigoni Garola
+# repo_url: https://github.com/cmt/ulib
+# docs_dir: docs
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | This is the main file used by MkDocs to build the pages.                                               |
+# | It contains a lot of information and settings for you to read and use.                                 |
+# | Comments may contain "Read More" URLs to more in-depth documentation about the option for you to read. |
+# |                                                                                                        |
+# | You can check out https://www.mkdocs.org/user-guide/configuration/ for a more detailed explanation of  |
+# | all the options MkDocs offers by default.                                                              |
+# |                                                                                                        |
+# +------------------------------------------------- NOTE -------------------------------------------------+
+# |                                                                                                        |
+# | Some of the options listed here are only available through the usage of Material for MkDocs.           |
+# | Those options will usually have a link to the docs of this Theme and also mention "Material" as name.  |
+# | The actual name of the theme is "Material for MkDocs" and "Material" is used for simplicity reasons.   |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | Main Page Settings for MkDocs.                                                                         |
+# | Those settings are site name, site description, Site author and also Site URL (Canonical URL)          |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_name                                           |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_description                                    |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_author                                         |
+# | - https://www.mkdocs.org/user-guide/configuration/#site_url                                            |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+site_name: OpenCMT uLib Documentation
+site_url: https://docs.mildstone.org/uLib/ # <--- project subfolder
+use_directory_urls: true
+site_description: 'Documentation for OpenCMT uLib'
+site_author: 'Andrea Rigoni Garola'
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | This setting allows you to define your own Copyright notice.                                           |
+# | The text is treated as HTML code so you can use things like <a> tags or &copy; to display the          |
+# | Copyright icon.                                                                                        |
+# |                                                                                                        |
+# | Where or IF the Copyright is displayed depends on the theme you use.                                   |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#copyright                                           |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+copyright: |
+  &copy; Author
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The base folder to use.                                                                                |
+# | Any Markdown files you put into this folder will be turned into a static HTML page once you build or   |
+# | publish your page.                                                                                     |
+# |                                                                                                        |
+# | It is also used as the base directory for other settings like the "extra_css" or "extra_javascript"    |
+# | option.                                                                                                |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+docs_dir: docs/
+
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | These options allow to define a Repository to link to.                                                 |
+# | The result will, depending on the theme, be a link somewhere shown on the page that links to the       |
+# | Repository with the specified repo_name.                                                               |
+# |                                                                                                        |
+# | This will also enable a "edit" button on the page itself that allows the direct editing of the page.   |
+# | You can disable this by setting "edit_uri" to an empty String.                                         |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#repo_name                                           |
+# | - https://www.mkdocs.org/user-guide/configuration/#repo_url                                            |
+# | - https://www.mkdocs.org/user-guide/configuration/#edit_uri                                            |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+repo_name: OpenCMT/uLib
+repo_url: https://gitea.mildstone.org/OpenCMT/uLib.git
+#edit_uri: tree/master/docs # Uncomment to define a different URI/URL for the "edit" option
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The "nav" option is where you define the navigation to show in MkDocs.                                 |
+# |                                                                                                        |
+# | Depending on the theme you use will the resulting Navigation look different.                           |
+# |                                                                                                        |
+# | You can set different types of navigations. Either just the path, the path with a separate title or    |
+# | an external URL.                                                                                       |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#documentation-layout                                |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+
+nav:
+  - Home: index.md
+  - Python:
+    - Installation: python/installation.md
+    - API Usage: python/usage.md
+    - Developer Guide: python/developer_guide.md
+  - C++ Build:
+    - Usage & CUDA: usage/usage.md
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The "theme" section allows you to define what theme to use.                                            |
+# | It is also used for theme-specific options, but also for advanced stuff such as theme-extensions, if   |
+# | the theme actually supports it.                                                                        |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#theme                                               |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+theme:
+
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "name" option is where you define the theme to use.                                              |
+  # |                                                                                                      |
+  # | Note that not all themes are included by default and will require you to install them first.         |
+  # | The Material theme is one of them. See the "Read More" link for instructions on how to install it.   |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/getting-started/                                       |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  name: 'material'
+
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The Material theme allows "theme-extsnions", meaning that you can override parts of it by either     |
+  # | overriding a particular file, or only parts (blocks) of it.                                          |
+  # |                                                                                                      |
+  # | If you want to override parts of Material, uncomment the "custom_dir" option below and set the       |
+  # | folder (relative to the mkdocs.yml file) where your theme extensions will be located at.             |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://www.mkdocs.org/user-guide/configuration/#custom_dir                                        |
+  # | - https://squidfunk.github.io/mkdocs-material/customization/#extending-the-theme                     |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #custom_dir: 'theme'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "favicon" option allows you to set your own image/icon to use in the browser-tab.                |
+  # |                                                                                                      |
+  # | Pretty much all image types are supported, but it's recommended to use a PNG, SVG or ICO image for   |
+  # | the favicon.                                                                                         |
+  # |                                                                                                      |
+  # | The directory is relative to the "docs_dir".                                                         |
+  # |                                                                                                      |
+  # | Example: Having a favicon.png in docs/assets/images will result in the "favicon" setting showing     |
+  # |          'assets/images/favicon.png'                                                                 |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-logo-and-icons/#favicon             |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #favicon: 'assets/images/favicon.png'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "palette" section is a Material option and allows you to define specific style options such as   |
+  # | Color-Scheme, and primary and secondary Color.                                                       |
+  # |                                                                                                      |
+  # | You can also define multiple palettes that can have different Color Schemses and primary and/or      |
+  # | secondary Colors.                                                                                    |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/                             |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#color-palette-toggle        |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  palette:
+  
+    # Palette toggle for light mode
+    - media: "(prefers-color-scheme: light)"
+      scheme: default
+      primary: 'indigo'
+      accent: 'indigo'
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+
+    # Palette toggle for dark mode
+    - media: "(prefers-color-scheme: dark)"
+      scheme: slate
+      primary: 'indigo'
+      accent: 'indigo'
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
+    
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | With the "font" option can you set a different font to use.                                          |
+  # |                                                                                                      |
+  # | Material supports all Google fonts, but you can also define your own ones if you choose so.          |
+  # |                                                                                                      |
+  # | The "text" option is used for the regular font while "code" is used for code blocks, inline code and |
+  # | similar.                                                                                             |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-fonts/                              |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #font:
+  #  text: 'Roboto'
+  #  code: 'Roboto Mono'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | Material suppors more than 40 different languages which you can set using the "language" option      |
+  # | below.                                                                                               |
+  # |                                                                                                      |
+  # | The default language is "en" (English).                                                              |
+  # |                                                                                                      |
+  # | You can also enable/set a "selector" to allow switching between languages.                           |
+  # | See the "alternate" option in the "extra" section below for more information on this topic.          |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-language/                           |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #language: 'en'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "direction" option is commonly used together with the "language" option.                         |
+  # |                                                                                                      |
+  # | It allows you to change the text direction from the default left-to-right (ltr) to right-to-left     |
+  # | (rtl) which is used in certain languages.                                                            |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-language/#directionality            |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #direction: 'ltr'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "features" option allows you to enable specific features of Material, by adding them to the      |
+  # | list.                                                                                                |
+  # |                                                                                                      |
+  # | Features are in the format <category>.<name>. As an example, the feature to enable tabs is called    |
+  # | navigation.tabs.                                                                                     |
+  # |                                                                                                      |
+  # | The list below contains all known features of Material.                                              |
+  # |                                                                                                      |
+  # | Features marked with a * are currently Insiders-only. (Last update: 11th December 2021)              |
+  # | https://squidfunk.github.io/mkdocs-material/insiders/                                                |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/setting-up-navigation/                           |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  features:
+  # Announce
+  #
+  #- announce.dismiss # Adds a "X" button to dismiss a news banner/mark it as read.*
+  
+  # Header
+  #
+  #- header.autohide # Hide header when user scrolls past a specific point.
+  
+  # Navigation:
+  #
+  #- navigation.expand      # Expand all collapsable sections.
+  #- navigation.instant     # Instant loading pages.
+  #- navigation.indexes     # Attach pages directly to Sections. Incompatible with "toc.integrate"
+  #- navigation.sections    # Render top sections as groups.
+  - navigation.tabs         # Render top sections as tabs at the top.
+  #- navigation.tabs.sticky # Tabs won't disappear when scrolling down. Requires "navigation.tabs".
+  #- navigation.top         # Adds a "Back to top" that is shown when scrolling up.
+  #- navigation.tracking    # Updates the url with highlighted section anchor.
+  
+  # Search
+  #
+  #- search.highlight # Search will highlight the searched word(s) on the page.*
+  #- search.share     # Adds an option to share a search query link.*
+  #- search.suggest   # Search will suggest the likeliest completion for a word.*
+  
+  # Table of Contents
+  #
+  #- toc.integrate          # Include the TOC sections in the left navugation.
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "icon" section allows you to define a icon to use for the logo and/or repository.                |
+  # |                                                                                                      |
+  # | To use already available icons will you need to set the right path for it, depending on which you    |
+  # | want to use.                                                                                         |
+  # |                                                                                                      |
+  # | Available icons:                                                                                     |
+  # | - FontAwesome                                                                                        |
+  # |   - Brands:  fontawesome/brands/...  (https://fontawesome.com/icons?d=gallery&p=2&s=brands&m=free)   |
+  # |   - Regular: fontawesome/regular/... (https://fontawesome.com/icons?d=gallery&p=2&s=regular&m=free)  |
+  # |   - Solid:   fontawesome/solid/...   (https://fontawesome.com/icons?d=gallery&p=2&s=solid&m=free)    |
+  # |                                                                                                      |
+  # | - Material Design Icons: material/... (https://materialdesignicons.com/)                             |
+  # |                                                                                                      |
+  # | - Octicons: octicons/... (https://primer.style/octicons/)                                            |
+  # |                                                                                                      |
+  # | You can also define your own Image for the logo. To do that, remove the "logo" option from "icon"    |
+  # | instead add a "logo" option on the same level as the "icon" one, where you then set the path         |
+  # | (relative to the "docs_dir") to the icon to use. Supported are all images types, including SVG.      |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-logo-and-icons/#logo                |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  icon:
+    logo: 'material/library'
+    repo: 'material/library'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "admonition" option allows you to set a different icon for each admonition type.                 |
+  # |                                                                                                      |
+  # | This is currently a Insiders-only feature. (Last update: 7th October 2021)                           |
+  # | https://squidfunk.github.io/mkdocs-material/insiders/                                                |
+  # |                                                                                                      |
+  # | Supported are all bundled icons:                                                                     |
+  # | - FontAwesome                                                                                        |
+  # |   - Brands:  fontawesome/brands/...  (https://fontawesome.com/icons?d=gallery&p=2&s=brands&m=free)   |
+  # |   - Regular: fontawesome/regular/... (https://fontawesome.com/icons?d=gallery&p=2&s=regular&m=free)  |
+  # |   - Solid:   fontawesome/solid/...   (https://fontawesome.com/icons?d=gallery&p=2&s=solid&m=free)    |
+  # |                                                                                                      |
+  # | - Material Design Icons: material/... (https://materialdesignicons.com/)                             |
+  # |                                                                                                      |
+  # | - Octicons: octicons/... (https://primer.style/octicons/)                                            |
+  # |                                                                                                      |
+  # | You can also create and use your own icons. See the documentation for more information.              |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/reference/admonitions/#changing-the-icons              |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #admonition:
+  #    note: 'octicons/tag-16'
+  #    abstract: 'octicons/checklist-16'
+  #    info: 'octicons/info-16'
+  #    tip: 'octicons/squirrel-16'
+  #    success: 'octicons/check-16'
+  #    question: 'octicons/question-16'
+  #    warning: 'octicons/alert-16'
+  #    failure: 'octicons/x-circle-16'
+  #    danger: 'octicons/zap-16'
+  #    bug: 'octicons/bug-16'
+  #    example: 'octicons/beaker-16'
+  #    quote: 'octicons/quote-16'
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | With the "extra_css" option can you add your own (S)CSS files to enhance the documentation.            |
+# |                                                                                                        |
+# | The path to the file is relative to the "docs_dir".                                                    |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#extra_css                                           |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+extra_css:
+  - assets/css/extra.css
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | Similar to the "extra_css" option does the "extra_javascript" option allow you to set custom JS files  |
+# | to add extra featurues.                                                                                |
+# |                                                                                                        |
+# | The path to the file is relative to the "docs_dir".                                                    |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#extra_javascript                                    |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+extra_javascript:
+  - https://polyfill.io/v3/polyfill.min.js?features=es6
+  - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | The "extra" section contains pretty much anything you want, as long as it is a valid key-value pair.   |
+# |                                                                                                        |
+# | Material uses this section for different custom settings that wouldn't fit in the theme section.       |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#extra                                               |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+extra:
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The social section allows you to set a list of entries which would be displayed in the footer of the |
+  # | page.                                                                                                |
+  # |                                                                                                      |
+  # | Each entry has the exact same options:                                                               |
+  # | - icon: Path to the SVG icon to use. See "icon" section for available icon sets.                     |
+  # | - link: URL to which the icon should link.                                                           |
+  # | - name: Optional Name that would be displayed as title on hover.                                     |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/setting-up-the-footer/#social-links              |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  social:
+    - icon: 'fontawesome/brands/github'
+      link: 'https://github.com/Andre601/mkdocs-template'
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | Allows you to hide the "Made with Material for MkDocs" text in the footer of the pages by setting    |
+  # | this to "true".                                                                                      |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/setting-up-the-footer/#generator-notice          |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #generator: true
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "manifest" option allows you to define a .manifest file to use.                                  |
+  # |                                                                                                      |
+  # | A .manifest file makes the doc act like a web-application and tells it how to behave when installed. |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/reference/meta-tags/#adding-a-web-app-manifest         |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #manifest: manifest.webmanifest
+  
+  # +------------------------------------------------------------------------------------------------------+
+  # |                                                                                                      |
+  # | The "alternate" option can be used to create a selector to switch languages.                         |
+  # |                                                                                                      |
+  # | Using this requires you to create a specific, more complicated MkDocs setup.                         |
+  # |                                                                                                      |
+  # | A Setup Guide for multi-language docs can be found here:                                             |
+  # | https://github.com/squidfunk/mkdocs-material/discussions/2346                                        |
+  # |                                                                                                      |
+  # | Read More:                                                                                           |
+  # | - https://squidfunk.github.io/mkdocs-material/setup/changing-the-language/#site-language-selector    |
+  # |                                                                                                      |
+  # +------------------------------------------------------------------------------------------------------+
+  #alternate:
+
+# +--------------------------------------------------------------------------------------------------------+
+# |                                                                                                        |
+# | MkDocs allows the usage of Markdown extensions which can do various things.                            |
+# |                                                                                                        |
+# | Material includes the pymdownx extension which provides a lot of useful features to use.               |
+# |                                                                                                        |
+# | Note that some extensions may use specific settings that you need to set.                              |
+# | Please check out the official documentation of PyMdownx for more information:                          |
+# | https://facelessuser.github.io/pymdown-extensions/                                                     |
+# |                                                                                                        |
+# | Material already provides required CSS and JS values for the PyMdownX Extensions, which means you do   |
+# | not need to set them up yourself.                                                                      |
+# |                                                                                                        |
+# | Read More:                                                                                             |
+# | - https://www.mkdocs.org/user-guide/configuration/#markdown_extensions                                 |
+# |                                                                                                        |
+# +--------------------------------------------------------------------------------------------------------+
+markdown_extensions:
+  - markdown.extensions.admonition:
+  - markdown.extensions.codehilite:
+      guess_lang: false
+  - markdown.extensions.toc:
+      permalink: true
+  - pymdownx.arithmatex:
+      generic: true
+  - attr_list
+  - md_in_html
+  - pymdownx.blocks.caption
+  - admonition
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.superfences
+  - pymdownx.tabbed:
+      alternate_style: true
+  - pymdownx.details
+  - attr_list
+  - tables
+
+  #- pymdownx.b64:
+  #- pymdownx.betterem:
+  #- pymdownx.caret:
+  #- pymdownx.critic:
+  #- pymdownx.details:
+  #- pymdownx.emoji:
+  #- pymdownx.escapeall:
+  #- pymdownx.extra:
+  #- pymdownx.extrarawhtml:
+  #- pymdownx.highlight:
+  #- pymdownx.inlinehilite:
+  #- pymdownx.keys:
+  #- pymdownx.magiclink:
+  #- pymdownx.mark:
+  #- pymdownx.pathconverter:
+  #- pymdownx.progressbar:
+  #- pymdownx.smartsymbols:
+  #- pymdownx.snippets:
+  #- pymdownx.striphtml:
+  #- pymdownx.superfences:
+  #- pymdownx.tabbed:
+  #- pymdownx.tasklist:
+  #- pymdownx.tilde:
+  # - exporter:
+  #     formats:
+  #       pdf:
+  #         enabled: !ENV [MKDOCS_EXPORTER_PDF, true]
+  #         concurrency: 8
+  #         stylesheets:
+  #           - resources/stylesheets/pdf.scss
+  #         covers:
+  #           front: resources/templates/covers/front.html.j2
+  #           back: resources/templates/covers/back.html.j2
+  #         aggregator:
+  #           enabled: true
+  #           output: .well-known/site.pdf
+  #           covers: all
+
+# theme:
+#   name: material
+#   palette:
+#     - scheme: default
+#       primary: indigo
+#       accent: blue
+#       toggle:
+#         icon: material/brightness-7
+#         name: Switch to dark mode
+#     - scheme: slate
+#       primary: indigo
+#       accent: blue
+#       toggle:
+#         icon: material/brightness-4
+#         name: Switch to light mode
+#   features:
+#     - navigation.tabs
+#     - navigation.sections
+#     - navigation.top
+#     - content.code.copy
+#     - content.tabs.link
+
+# plugins:
+#   - search
+
+# markdown_extensions:
+
+
--- a/poetry.lock
+++ b/poetry.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Poetry 2.3.1 and should not be changed by hand.
+package = []
+
+[metadata]
+lock-version = "2.1"
+python-versions = ">=3.9"
+content-hash = "db9b4c08b159b17b239e26c67ead7c37b82d9f9eb06550245ae3134c095f98f7"
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -0,0 +1,15 @@
+[tool.poetry]
+name = "uLib"
+version = "0.6.0"
+description = "CMT Cosmic Muon Tomography project uLib python bindings"
+authors = ["Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>"]
+readme = "README.md"
+packages = [{ include = "uLib", from = "src/Python" }]
+build = "build_python.py"
+
+[tool.poetry.dependencies]
+python = ">=3.9"
+
+[build-system]
+requires = ["poetry-core>=2.0.0", "pybind11>=2.6.0", "cmake>=3.12"]
+build-backend = "poetry.core.masonry.api"
--- a/src/Core/Archives.h
+++ b/src/Core/Archives.h
@@ -23,14 +23,12 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_CORE_ARCHIVES_H
 #define U_CORE_ARCHIVES_H

-
 #include <boost/archive/detail/basic_pointer_iserializer.hpp>
 #include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <iostream>

 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
@@ -40,25 +38,20 @@

 #include <boost/archive/detail/register_archive.hpp>

-#include <boost/archive/polymorphic_iarchive.hpp>
-#include <boost/archive/polymorphic_oarchive.hpp>
 #include <boost/archive/detail/polymorphic_iarchive_route.hpp>
 #include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+#include <boost/archive/polymorphic_iarchive.hpp>
+#include <boost/archive/polymorphic_oarchive.hpp>

 #include <boost/archive/polymorphic_text_oarchive.hpp>

 #include "StringReader.h"

-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // FWD DECLARATIONS OF ARCHIVES //

-
-
-
 namespace uLib {
 namespace Archive {

@@ -68,40 +61,36 @@ class text_iarchive;
 class text_oarchive;
 class log_archive;

-
-}
-}
-
+} // namespace Archive
+} // namespace uLib

 namespace boost {
 namespace archive {
 namespace detail {
-template<class ArchiveImplementation> class polymorphic_oarchive_route;
-template<class ArchiveImplementation> class polymorphic_iarchive_route;
-}
-}
-}
+template <class ArchiveImplementation> class polymorphic_oarchive_route;
+template <class ArchiveImplementation> class polymorphic_iarchive_route;
+} // namespace detail
+} // namespace archive
+} // namespace boost

 namespace boost {
 namespace serialization {
-    template <typename T> struct hrp;
+template <typename T> struct hrp;
 }
-}
-
+} // namespace boost

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // ARCHIVES REGISTRATION //

-
 namespace uLib {
 namespace Archive {
 namespace detail {
 struct adl_tag {};
-}
-}
-}
+} // namespace detail
+} // namespace Archive
+} // namespace uLib

 namespace boost {
 namespace archive {
@@ -110,34 +99,36 @@ namespace detail {
 // in overload resolution with the functions declared by
 // BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
 template <class Serializable>
-void instantiate_ptr_serialization(Serializable*, int, uLib::Archive::detail::adl_tag ) {}
-}
-}
-}
+void instantiate_ptr_serialization(Serializable *, int,
+                                   uLib::Archive::detail::adl_tag) {}
+} // namespace detail
+} // namespace archive
+} // namespace boost

 // The function declaration generated by this macro never actually
 // gets called, but its return type gets instantiated, and that's
 // enough to cause registration of serialization functions between
 // Archive and any exported Serializable type.  See also:
 // boost/serialization/export.hpp
-# define ULIB_SERIALIZATION_REGISTER_ARCHIVE(_Archive)                  \
-namespace boost { namespace archive { namespace detail {                \
+#define ULIB_SERIALIZATION_REGISTER_ARCHIVE(_Archive)                          \
+  namespace boost {                                                            \
+  namespace archive {                                                          \
+  namespace detail {                                                           \
                                                                               \
-template <class Serializable>                                           \
-BOOST_DEDUCED_TYPENAME _ptr_serialization_support<_Archive, Serializable>::type  \
-instantiate_ptr_serialization( Serializable*, _Archive*, uLib::Archive::detail::adl_tag ); }}}
-
-
-
-
-
+  template <class Serializable>                                                \
+  BOOST_DEDUCED_TYPENAME                                                       \
+      _ptr_serialization_support<_Archive, Serializable>::type                 \
+      instantiate_ptr_serialization(Serializable *, _Archive *,                \
+                                    uLib::Archive::detail::adl_tag);           \
+  }                                                                            \
+  }                                                                            \
+  }

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // ARCHIVES IO INTERFACES //

-
 namespace boost {
 namespace archive {
 namespace detail {
@@ -145,11 +136,10 @@ namespace detail {
 /**
 * Custom implementation of boost interface_iarchive to add new operators
 */
-template<class Archive>
-class uLib_interface_iarchive
-{
+template <class Archive> class uLib_interface_iarchive {
 protected:
-    uLib_interface_iarchive(){};
+  uLib_interface_iarchive() {};
+
 public:
  /////////////////////////////////////////////////////////
  // archive public interface
@@ -157,54 +147,40 @@ public:
  typedef mpl::bool_<false> is_saving;

  // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
+  Archive *This() { return static_cast<Archive *>(this); }

-    template<class T>
-    const basic_pointer_iserializer *
-    register_type(T * = NULL){
-        const basic_pointer_iserializer & bpis =
-            boost::serialization::singleton<
-                pointer_iserializer<Archive, T>
-            >::get_const_instance();
+  template <class T>
+  const basic_pointer_iserializer *register_type(T * = NULL) {
+    const basic_pointer_iserializer &bpis = boost::serialization::singleton<
+        pointer_iserializer<Archive, T>>::get_const_instance();
    this->This()->register_basic_serializer(bpis.get_basic_serializer());
-        return & bpis;
+    return &bpis;
  }
-    template<class T>
-    Archive & operator>>(T & t){
-        this->This()->load_override(t, 0);
-        return * this->This();
+  template <class T> Archive &operator>>(T &t) {
+    this->This()->load_override(t);
+    return *this->This();
  }

  // the & operator
-    template<class T>
-    Archive & operator&(T & t){
-        return *(this->This()) >> t;
-    }
+  template <class T> Archive &operator&(T &t) { return *(this->This()) >> t; }

  // the == operator
-    template <class T>
-    Archive & operator == (T & t) {
-        return this->operator &(t);
-    }
+  template <class T> Archive &operator==(T &t) { return this->operator&(t); }

  // the != operator for human readable access
-    template <class T>
-    Archive & operator != (T & t) {
+  template <class T> Archive &operator!=(T &t) {
    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
-        return * this->This();
+    return *this->This();
  }
 };

-
 /**
 * Custom implementation of boost interface_oarchive to add new operators
 */
-template <class Archive>
-class uLib_interface_oarchive {
+template <class Archive> class uLib_interface_oarchive {
 protected:
-    uLib_interface_oarchive(){};
+  uLib_interface_oarchive() {};
+
 public:
  /////////////////////////////////////////////////////////
  // archive public interface
@@ -212,109 +188,82 @@ public:
  typedef mpl::bool_<true> is_saving;

  // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
+  Archive *This() { return static_cast<Archive *>(this); }

-    template<class T>
-    const basic_pointer_oserializer *
-    register_type(const T * = NULL){
-        const basic_pointer_oserializer & bpos =
-            boost::serialization::singleton<
-                pointer_oserializer<Archive, T>
-            >::get_const_instance();
+  template <class T>
+  const basic_pointer_oserializer *register_type(const T * = NULL) {
+    const basic_pointer_oserializer &bpos = boost::serialization::singleton<
+        pointer_oserializer<Archive, T>>::get_const_instance();
    this->This()->register_basic_serializer(bpos.get_basic_serializer());
-        return & bpos;
+    return &bpos;
  }

-    template<class T>
-    Archive & operator<<(T & t){
+  template <class T> Archive &operator<<(T &t) {
    // to get access you must redefine save_override by typing
    // "using save_override" in archive impl
-        this->This()->save_override(t, 0);
-        return * this->This();
+    this->This()->save_override(t);
+    return *this->This();
  }

  // the & operator
-    template<class T>
-    Archive & operator&(T & t){
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-            return * this->This() << const_cast<const T &>(t);
-        #else
-            return * this->This() << t;
-        #endif
+  template <class T> Archive &operator&(T &t) {
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    return *this->This() << const_cast<const T &>(t);
+#else
+    return *this->This() << t;
+#endif
  }

  // the == operator
-    template <class T>
-    Archive & operator == (T & t) {
-        return this->operator &(t);
-    }
+  template <class T> Archive &operator==(T &t) { return this->operator&(t); }

  // the != operator for human readable access
-    template <class T>
-    Archive & operator != (T & t) {
+  template <class T> Archive &operator!=(T &t) {
    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
-        return * this->This();
+    return *this->This();
  }
 };

-
-
 // DECLARE INTERFACE SPECIALIZATIONS ///////////////////////////////////////////
 // With this declarations all uLib archive Implementation will use their own
 // extended interface //

 template <>
-class interface_iarchive        <uLib::Archive::xml_iarchive> : public
-        uLib_interface_iarchive <uLib::Archive::xml_iarchive> {};
+class interface_iarchive<uLib::Archive::xml_iarchive>
+    : public uLib_interface_iarchive<uLib::Archive::xml_iarchive> {};

 template <>
-class interface_oarchive        <uLib::Archive::xml_oarchive> : public
-        uLib_interface_oarchive <uLib::Archive::xml_oarchive> {};
+class interface_oarchive<uLib::Archive::xml_oarchive>
+    : public uLib_interface_oarchive<uLib::Archive::xml_oarchive> {};

 template <>
-class interface_iarchive        <uLib::Archive::text_iarchive> : public
-        uLib_interface_iarchive <uLib::Archive::text_iarchive> {};
+class interface_iarchive<uLib::Archive::text_iarchive>
+    : public uLib_interface_iarchive<uLib::Archive::text_iarchive> {};

 template <>
-class interface_oarchive        <uLib::Archive::text_oarchive> : public
-        uLib_interface_oarchive <uLib::Archive::text_oarchive> {};
+class interface_oarchive<uLib::Archive::text_oarchive>
+    : public uLib_interface_oarchive<uLib::Archive::text_oarchive> {};

 template <>
-class interface_oarchive        <uLib::Archive::log_archive> : public
-        uLib_interface_oarchive <uLib::Archive::log_archive> {};
-
+class interface_oarchive<uLib::Archive::log_archive>
+    : public uLib_interface_oarchive<uLib::Archive::log_archive> {};

 //// Veritical repetition macro // FINIRE !!!!!!!!!!!!!!!!!!!!!!!!!
-//#define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata)           \
+// #define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata)           \
 //     template <class TypeSeq>                             \
 //     struct inherit_nofold<TypeSeq,BOOST_PP_INC(vn)> :    \
 //     BOOST_PP_REPEAT(BOOST_PP_INC(vn),_INERIT_NOFOLD_H,~) \
 //     {};

 //// Multiple size declaration //
-//BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
-
-//#undef  _INERIT_NOFOLD_H
-//#undef  _INERIT_NOFOLD_V
-
-
-} // detail
-} // archive
-} // boost
-
-
-
-
-
-
-
-
-
-
+// BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)

+// #undef  _INERIT_NOFOLD_H
+// #undef  _INERIT_NOFOLD_V

+} // namespace detail
+} // namespace archive
+} // namespace boost

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -330,14 +279,14 @@ class interface_oarchive        <uLib::Archive::log_archive> : public
 namespace boost {
 namespace archive {

-//template<class Archive>
-//inline void load_const_override(Archive & ar, const char *t ){
-//    typedef typename mpl::identity<detail::load_non_pointer_type<Archive> >::type typex;
-//    typex::invoke(ar, t);
-//}
+// template<class Archive>
+// inline void load_const_override(Archive & ar, const char *t ){
+//     typedef typename mpl::identity<detail::load_non_pointer_type<Archive>
+//     >::type typex; typex::invoke(ar, t);
+// }

-//template<class Archive, class T>
-//inline void load(Archive & ar, T &t){
+// template<class Archive, class T>
+// inline void load(Archive & ar, T &t){
 //     // if this assertion trips. It means we're trying to load a
 //     // const object with a compiler that doesn't have correct
 //     // funtion template ordering.  On other compilers, this is
@@ -358,47 +307,38 @@ namespace archive {
 //         >
 //         >::type typex;
 //     typex::invoke(ar, t);
-//}
-
-
-
-}
-}
-
-
+// }

+} // namespace archive
+} // namespace boost

 namespace uLib {

 namespace Archive {

-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // POLYMORPHIC //

-
-//class polymorphic_iarchive :
+// class polymorphic_iarchive :
 //         public boost::archive::polymorphic_iarchive {

-//public:
+// public:
 //     void load_override(const char *t, BOOST_PFTO int)
 //     {
-//        boost::archive::load_const_override(* this->This(), const_cast<char*>(t));
+//         boost::archive::load_const_override(* this->This(),
+//         const_cast<char*>(t));
 //     }

 //};

-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // XML //

-class xml_iarchive :
-    public boost::archive::xml_iarchive_impl<xml_iarchive>
-{
+class xml_iarchive : public boost::archive::xml_iarchive_impl<xml_iarchive> {
  typedef xml_iarchive Archive;
  typedef boost::archive::xml_iarchive_impl<Archive> base;

@@ -406,75 +346,63 @@ class xml_iarchive :
  friend class boost::archive::detail::interface_iarchive<Archive>;
  friend class boost::archive::basic_xml_iarchive<Archive>;
  friend class boost::archive::load_access;
+
 public:
-    xml_iarchive(std::istream & is, unsigned int flags = 0) :
-        xml_iarchive_impl<xml_iarchive>(is, flags)
-    {}
+  xml_iarchive(std::istream &is, unsigned int flags = 0)
+      : xml_iarchive_impl<xml_iarchive>(is, flags) {}

  using basic_xml_iarchive::load_override;

  // Anything not an attribute should be a name value pair as nvp or hrp
-    typedef boost::archive::detail::common_iarchive<Archive> detail_common_iarchive;
-    template<class T>
+  typedef boost::archive::detail::common_iarchive<Archive>
+      detail_common_iarchive;
+  template <class T>
  void load_override(
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
      const
-        #endif
-        boost::serialization::hrp< T > & t,
-        int v
-    ){
+#endif
+      boost::serialization::hrp<T> &t) {
    this->This()->load_start(t.name());
-        this->detail_common_iarchive::load_override(t.value(), 0);
-//        t.stov();
+    this->detail_common_iarchive::load_override(t.value());
+    //        t.stov();
    this->This()->load_end(t.name());
  }

-
  // class_name_type can't be handled here as it depends upon the
  // char type used by the stream.  So require the derived implementation.
  // derived in this case is xml_iarchive_impl or base ..
  using base::load_override;

-    void load_override(const char *str, int v) {
+  void load_override(const char *str) {
    //        StringReader sr(basic_text_iprimitive::is);
    //        sr >> str;
  }

-    ~xml_iarchive(){};
+  ~xml_iarchive() {};
 };

-//typedef boost::archive::detail::polymorphic_iarchive_route<
-//boost::archive::xml_iarchive_impl<xml_iarchive>
+// typedef boost::archive::detail::polymorphic_iarchive_route<
+// boost::archive::xml_iarchive_impl<xml_iarchive>
 //> polymorphic_xml_iarchive;

 template <class ArchiveImpl>
-struct polymorphic_iarchive_route :
-        boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl>
-{
-    virtual void load(const char * t){
-        ArchiveImpl::load(t);
-    }
+struct polymorphic_iarchive_route
+    : boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl> {
+  virtual void load(const char *t) { ArchiveImpl::load(t); }
 };

-
-class polymorphic_xml_iarchive :
-        public  polymorphic_iarchive_route< boost::archive::xml_iarchive_impl<xml_iarchive> >
-{
+class polymorphic_xml_iarchive
+    : public polymorphic_iarchive_route<
+          boost::archive::xml_iarchive_impl<xml_iarchive>> {
  // give serialization implementation access to this class
-//    friend class boost::archive::detail::interface_iarchive<Archive>;
-//    friend class boost::archive::basic_xml_iarchive<Archive>;
-//    friend class boost::archive::load_access;
+  //    friend class boost::archive::detail::interface_iarchive<Archive>;
+  //    friend class boost::archive::basic_xml_iarchive<Archive>;
+  //    friend class boost::archive::load_access;
 public:
-    virtual void load_override(const char *str, int v) {
-        ;
-    }
+  virtual void load_override(const char *str) { ; }
 };

-
-
-class xml_oarchive :
-    public boost::archive::xml_oarchive_impl<xml_oarchive>
-{
+class xml_oarchive : public boost::archive::xml_oarchive_impl<xml_oarchive> {
  typedef xml_oarchive Archive;
  typedef boost::archive::xml_oarchive_impl<Archive> base;

@@ -482,10 +410,10 @@ class xml_oarchive :
  friend class boost::archive::detail::interface_oarchive<Archive>;
  friend class boost::archive::basic_xml_oarchive<Archive>;
  friend class boost::archive::save_access;
+
 public:
-    xml_oarchive(std::ostream & os, unsigned int flags = 0) :
-        boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags)
-    {}
+  xml_oarchive(std::ostream &os, unsigned int flags = 0)
+      : boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}

  // example of implementing save_override for const char* //
  //    void save_override(const char *t, int) {
@@ -495,31 +423,30 @@ public:
  using basic_xml_oarchive::save_override;

  // special treatment for name-value pairs.
-    typedef boost::archive::detail::common_oarchive<Archive> detail_common_oarchive;
-    template<class T>
+  typedef boost::archive::detail::common_oarchive<Archive>
+      detail_common_oarchive;
+  template <class T>
  void save_override(
-        #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
      const
-        #endif
-        ::boost::serialization::hrp< T > & t,
-        int v
-    ){
+#endif
+      ::boost::serialization::hrp<T> &t) {
    this->This()->save_start(t.name());
-//        t.vtos();
-//        this->detail_common_oarchive::save_override(t.const_value(), 0);
+    //        t.vtos();
+    //        this->detail_common_oarchive::save_override(t.const_value());
    this->This()->save_end(t.name());
  }

-    void save_override(const char *str, int v) {
+  void save_override(const char *str) {
    // Do not save any human decoration string //
    //        basic_text_oprimitive::save(str);
  }

-    ~xml_oarchive(){}
+  ~xml_oarchive() {}
 };

-//typedef boost::archive::detail::polymorphic_oarchive_route<
-//boost::archive::xml_oarchive_impl<xml_oarchive>
+// typedef boost::archive::detail::polymorphic_oarchive_route<
+// boost::archive::xml_oarchive_impl<xml_oarchive>
 //> polymorphic_xml_oarchive;

 ////////////////////////////////////////////////////////////////////////////////
@@ -527,9 +454,7 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 // TEXT //

-class text_iarchive :
-    public boost::archive::text_iarchive_impl<text_iarchive>
-{
+class text_iarchive : public boost::archive::text_iarchive_impl<text_iarchive> {
  typedef text_iarchive Archive;
  typedef boost::archive::text_iarchive_impl<Archive> base;

@@ -537,21 +462,21 @@ class text_iarchive :
  friend class boost::archive::detail::interface_iarchive<Archive>;
  friend class boost::archive::basic_text_iarchive<Archive>;
  friend class boost::archive::load_access;
+
 public:
-    text_iarchive(std::istream & is, unsigned int flags = 0) :
-        text_iarchive_impl<Archive>(is, flags)
-    {}
+  text_iarchive(std::istream &is, unsigned int flags = 0)
+      : text_iarchive_impl<Archive>(is, flags) {}

  using basic_text_iarchive::load_override;

-    void load_override(boost::archive::object_id_type & t, int)               {}
+  void load_override(boost::archive::object_id_type &t) {}

  // class_name_type can't be handled here as it depends upon the
  // char type used by the stream.  So require the derived implementation.
  // derived in this case is xml_iarchive_impl or base ..
  using base::load_override;

-    void load_override(const char *str, int v) {
+  void load_override(const char *str) {
    StringReader sr(basic_text_iprimitive::is);
    sr >> str;
  }
@@ -561,15 +486,11 @@ public:

 typedef text_iarchive naked_text_iarchive;

-//typedef boost::archive::detail::polymorphic_iarchive_route<
-//naked_text_iarchive
+// typedef boost::archive::detail::polymorphic_iarchive_route<
+// naked_text_iarchive
 //> polymorphic_text_iarchive;

-
-
-class text_oarchive :
-    public boost::archive::text_oarchive_impl<text_oarchive>
-{
+class text_oarchive : public boost::archive::text_oarchive_impl<text_oarchive> {
  typedef text_oarchive Archive;
  typedef boost::archive::text_oarchive_impl<Archive> base;

@@ -577,33 +498,28 @@ class text_oarchive :
  friend class boost::archive::detail::interface_oarchive<Archive>;
  friend class boost::archive::basic_text_oarchive<Archive>;
  friend class boost::archive::save_access;
+
 public:
-    text_oarchive(std::ostream & os, unsigned int flags = 0) :
-        boost::archive::text_oarchive_impl<Archive>(os, flags)
-    {}
+  text_oarchive(std::ostream &os, unsigned int flags = 0)
+      : boost::archive::text_oarchive_impl<Archive>(os, flags) {}

  using basic_text_oarchive::save_override;

-    void save_override(const char *str, int v) {
-        basic_text_oprimitive::save(str);
-    }
+  void save_override(const char *str) { basic_text_oprimitive::save(str); }

-    ~text_oarchive(){}
+  ~text_oarchive() {}
 };

-//typedef boost::archive::detail::polymorphic_oarchive_route<
-//boost::archive::text_oarchive_impl<text_oarchive>
+// typedef boost::archive::detail::polymorphic_oarchive_route<
+// boost::archive::text_oarchive_impl<text_oarchive>
 //> polymorphic_text_oarchive;

-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // SIMPLE HUMAN READABLE TEXT //

-class hrt_iarchive :
-    public boost::archive::text_iarchive_impl<hrt_iarchive>
-{
+class hrt_iarchive : public boost::archive::text_iarchive_impl<hrt_iarchive> {
  typedef hrt_iarchive Archive;
  typedef boost::archive::text_iarchive_impl<Archive> base;

@@ -611,29 +527,29 @@ class hrt_iarchive :
  friend class boost::archive::detail::interface_iarchive<Archive>;
  friend class boost::archive::basic_text_iarchive<Archive>;
  friend class boost::archive::load_access;
+
 public:
-    hrt_iarchive(std::istream & is, unsigned int flags = 0) :
-        base(is, flags | boost::archive::no_header )
-    {}
+  hrt_iarchive(std::istream &is, unsigned int flags = 0)
+      : base(is, flags | boost::archive::no_header) {}

  using basic_text_iarchive::load_override;

  // hide all archive props //
-    void load_override( boost::archive::object_id_type & t, int)         {}
-    void load_override( boost::archive::object_reference_type & t, int)  {}
-    void load_override( boost::archive::version_type & t, int)           {}
-    void load_override( boost::archive::class_id_type & t, int)          {}
-    void load_override( boost::archive::class_id_optional_type & t, int) {}
-    void load_override( boost::archive::class_id_reference_type & t, int){}
-    void load_override( boost::archive::class_name_type & t, int)        {}
-    void load_override( boost::archive::tracking_type & t, int)          {}
+  void load_override(boost::archive::object_id_type &t) {}
+  void load_override(boost::archive::object_reference_type &t) {}
+  void load_override(boost::archive::version_type &t) {}
+  void load_override(boost::archive::class_id_type &t) {}
+  void load_override(boost::archive::class_id_optional_type &t) {}
+  void load_override(boost::archive::class_id_reference_type &t) {}
+  void load_override(boost::archive::class_name_type &t) {}
+  void load_override(boost::archive::tracking_type &t) {}

  // class_name_type can't be handled here as it depends upon the
  // char type used by the stream.  So require the derived implementation.
  // derived in this case is xml_iarchive_impl or base ..
  using base::load_override;

-    void load_override(const char *str, int v) {
+  void load_override(const char *str) {
    StringReader sr(basic_text_iprimitive::is);
    sr >> str;
  }
@@ -641,10 +557,7 @@ public:
  ~hrt_iarchive() {};
 };

-
-class hrt_oarchive :
-        public boost::archive::text_oarchive_impl<hrt_oarchive>
-    {
+class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
  typedef hrt_oarchive Archive;
  typedef boost::archive::text_oarchive_impl<Archive> base;

@@ -652,32 +565,26 @@ class hrt_oarchive :
  friend class boost::archive::detail::interface_oarchive<Archive>;
  friend class boost::archive::basic_text_oarchive<Archive>;
  friend class boost::archive::save_access;
-    public:
-        hrt_oarchive(std::ostream & os, unsigned int flags = 0) :
-            base(os, flags | boost::archive::no_header )
-        {}
+
+public:
+  hrt_oarchive(std::ostream &os, unsigned int flags = 0)
+      : base(os, flags | boost::archive::no_header) {}

  using basic_text_oarchive::save_override;

-        void save_override(const boost::archive::object_id_type & t, int)         {}
-        void save_override(const boost::archive::object_reference_type & t, int)  {}
-        void save_override(const boost::archive::version_type & t, int)           {}
-        void save_override(const boost::archive::class_id_type & t, int)          {}
-        void save_override(const boost::archive::class_id_optional_type & t, int) {}
-        void save_override(const boost::archive::class_id_reference_type & t, int){}
-        void save_override(const boost::archive::class_name_type & t, int)        {}
-        void save_override(const boost::archive::tracking_type & t, int)          {}
-
-
-        void save_override(const char *str, int v) {
-            basic_text_oprimitive::save(str);
-        }
-
-        ~hrt_oarchive(){}
-    };
-
+  void save_override(const boost::archive::object_id_type &t) {}
+  void save_override(const boost::archive::object_reference_type &t) {}
+  void save_override(const boost::archive::version_type &t) {}
+  void save_override(const boost::archive::class_id_type &t) {}
+  void save_override(const boost::archive::class_id_optional_type &t) {}
+  void save_override(const boost::archive::class_id_reference_type &t) {}
+  void save_override(const boost::archive::class_name_type &t) {}
+  void save_override(const boost::archive::tracking_type &t) {}

+  void save_override(const char *str) { basic_text_oprimitive::save(str); }

+  ~hrt_oarchive() {}
+};

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -690,8 +597,7 @@ class hrt_oarchive :
 // any serializable class.  Intended to be useful as a debugging aid.
 class log_archive :
    /* protected ? */
-    public boost::archive::xml_oarchive_impl<log_archive>
-{
+    public boost::archive::xml_oarchive_impl<log_archive> {
  typedef boost::archive::xml_oarchive_impl<log_archive> base;
  typedef log_archive Archive;
  // give serialization implementation access to this clas
@@ -700,66 +606,52 @@ class log_archive :
  friend class boost::archive::save_access;

 public:
-
-    void save_override(const char *str, int v) {
+  void save_override(const char *str) {
    // Do not save any human decoration string //
    //        basic_text_oprimitive::save(str);
  }

-    template<class T>
-    void save_override(T & t, BOOST_PFTO int){
-        base::save_override(boost::serialization::make_nvp(NULL, t), 0);
+  template <class T> void save_override(T &t) {
+    base::save_override(boost::serialization::make_nvp(NULL, t));
  }

  // activate this if you want to trap non nvp objects //
  //    template<class T>
-    //    void save_override(T & t, BOOST_PFTO int)
+  //    void save_override(T & t)
  //    {
  //        BOOST_MPL_ASSERT((boost::serialization::is_wrapper< T >));
-    //        //        this->detail_common_oarchive::save_override(t, 0);
+  //        //        this->detail_common_oarchive::save_override(t);
  //    }

-    template<class T>
-    void save_override(const boost::serialization::nvp<T> & t, int){
-        base::save_override(t, 0);
+  template <class T> void save_override(const boost::serialization::nvp<T> &t) {
+    base::save_override(t);
  }

-
  // specific overrides for attributes - not name value pairs so we
  // want to trap them before the above "fall through"
  // since we don't want to see these in the output - make them no-ops.
-    void save_override(const boost::archive::object_id_type & t, int)         {}
-    void save_override(const boost::archive::object_reference_type & t, int)  {}
-    void save_override(const boost::archive::version_type & t, int)           {}
-    void save_override(const boost::archive::class_id_type & t, int)          {}
-    void save_override(const boost::archive::class_id_optional_type & t, int) {}
-    void save_override(const boost::archive::class_id_reference_type & t, int){}
-    void save_override(const boost::archive::class_name_type & t, int)        {}
-    void save_override(const boost::archive::tracking_type & t, int)          {}
-
+  void save_override(const boost::archive::object_id_type &t) {}
+  void save_override(const boost::archive::object_reference_type &t) {}
+  void save_override(const boost::archive::version_type &t) {}
+  void save_override(const boost::archive::class_id_type &t) {}
+  void save_override(const boost::archive::class_id_optional_type &t) {}
+  void save_override(const boost::archive::class_id_reference_type &t) {}
+  void save_override(const boost::archive::class_name_type &t) {}
+  void save_override(const boost::archive::tracking_type &t) {}

 public:
-    log_archive(std::ostream & os, unsigned int flags = 0) :
-        boost::archive::xml_oarchive_impl<log_archive>(
-            os,
-            flags | boost::archive::no_header
-        )
-    {}
+  log_archive(std::ostream &os, unsigned int flags = 0)
+      : boost::archive::xml_oarchive_impl<log_archive>(
+            os, flags | boost::archive::no_header) {}
 };

-//typedef boost::archive::detail::polymorphic_oarchive_route<
-//boost::archive::xml_oarchive_impl<log_archive>
+// typedef boost::archive::detail::polymorphic_oarchive_route<
+// boost::archive::xml_oarchive_impl<log_archive>
 //> polymorphic_log_archive;

+} // namespace Archive

-
-
-} // Archive
-
-
-
-} // uLib
-
+} // namespace uLib

 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::xml_iarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::xml_oarchive)
@@ -769,13 +661,10 @@ ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_iarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_oarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::log_archive)

-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
-//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
-
-
-
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
+// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)

 #endif // U_CORE_ARCHIVES_H
--- a/src/Core/CMakeLists.txt
+++ b/src/Core/CMakeLists.txt
@@ -3,13 +3,13 @@ set(HEADERS
    Archives.h 
    Array.h 
    Collection.h 
+    DataAllocator.h 
    Debug.h 
    Export.h 
    Function.h 
    Macros.h 
    Mpl.h 
    Object.h 
-                                ObjectProps.h
    Options.h 
    Serializable.h 
    Signal.h 
@@ -20,12 +20,11 @@ set(HEADERS
    Types.h 
    Uuid.h 
    Vector.h
-                                CommaInitializer.h
-                                Timer.h
 )

-SET(SOURCES
+set(SOURCES 
    Archives.cpp 
+    Debug.cpp 
    Object.cpp 
    Options.cpp 
    Serializable.cpp 
@@ -33,14 +32,30 @@ SET(SOURCES
    Uuid.cpp
 )

-set(LIBRARIES
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-)
+set(LIBRARIES Boost::program_options Boost::serialization)

-uLib_add_shared_library(${uLib-module})
-add_subdirectory(testing)
+set(libname ${PACKAGE_LIBPREFIX}Core)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Core PARENT_SCOPE)
+
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION})
+if(USE_CUDA)
+  set(LIBRARIES ${LIBRARIES} CUDA::cudart)
+endif()
+
+target_link_libraries(${libname} ${LIBRARIES})
+
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()
--- a/src/Core/DataAllocator.h
+++ b/src/Core/DataAllocator.h
@@ -0,0 +1,260 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_MATH_DATAALLOCATOR_H
+#define U_MATH_DATAALLOCATOR_H
+
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+#include <stdexcept>
+#include <vector>
+
+#ifdef USE_CUDA
+#include <cuda_runtime.h>
+#include <thrust/device_vector.h>
+#endif
+
+namespace uLib {
+
+enum class MemoryDevice { RAM, VRAM };
+
+template <typename T> class DataAllocator {
+public:
+  DataAllocator(size_t size = 0, bool owns_objects = true)
+      : m_Size(size), m_RamData(nullptr), m_VramData(nullptr),
+        m_Device(MemoryDevice::RAM), m_OwnsObjects(owns_objects) {
+    if (m_Size > 0) {
+      if (m_OwnsObjects)
+        m_RamData = new T[m_Size]();
+      else
+        m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+    }
+  }
+
+  DataAllocator(const DataAllocator<T> &other)
+      : m_Size(other.m_Size), m_RamData(nullptr), m_VramData(nullptr),
+        m_Device(other.m_Device), m_OwnsObjects(other.m_OwnsObjects) {
+    if (m_Size > 0) {
+      if (other.m_RamData) {
+        if (m_OwnsObjects)
+          m_RamData = new T[m_Size];
+        else
+          m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+        std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+      }
+#ifdef USE_CUDA
+      if (other.m_VramData) {
+        cudaMalloc((void **)&m_VramData, m_Size * sizeof(T));
+        cudaMemcpy(m_VramData, other.m_VramData, m_Size * sizeof(T),
+                   cudaMemcpyDeviceToDevice);
+      }
+#endif
+    }
+  }
+
+  ~DataAllocator() {
+    if (m_RamData) {
+      if (m_OwnsObjects)
+        delete[] m_RamData;
+      else
+        ::operator delete(m_RamData);
+    }
+#ifdef USE_CUDA
+    if (m_VramData) {
+      cudaFree(m_VramData);
+    }
+#endif
+  }
+
+  DataAllocator &operator=(const DataAllocator &other) {
+    if (this != &other) {
+      m_OwnsObjects = other.m_OwnsObjects;
+      resize(other.m_Size);
+      m_Device = other.m_Device;
+      if (other.m_RamData) {
+        if (!m_RamData) {
+          if (m_OwnsObjects)
+            m_RamData = new T[m_Size];
+          else
+            m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+        }
+        std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
+      }
+#ifdef USE_CUDA
+      if (other.m_VramData) {
+        if (!m_VramData)
+          cudaMalloc((void **)&m_VramData, m_Size * sizeof(T));
+        cudaMemcpy(m_VramData, other.m_VramData, m_Size * sizeof(T),
+                   cudaMemcpyDeviceToDevice);
+      }
+#endif
+    }
+    return *this;
+  }
+
+  void MoveToRAM() {
+    if (m_Device == MemoryDevice::RAM)
+      return;
+    if (!m_RamData && m_Size > 0) {
+      if (m_OwnsObjects)
+        m_RamData = new T[m_Size]();
+      else
+        m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+    }
+#ifdef USE_CUDA
+    if (m_VramData && m_Size > 0) {
+      cudaMemcpy(m_RamData, m_VramData, m_Size * sizeof(T),
+                 cudaMemcpyDeviceToHost);
+    }
+#endif
+    m_Device = MemoryDevice::RAM;
+  }
+
+  void MoveToVRAM() {
+    if (m_Device == MemoryDevice::VRAM)
+      return;
+#ifdef USE_CUDA
+    if (!m_VramData && m_Size > 0) {
+      cudaMalloc((void **)&m_VramData, m_Size * sizeof(T));
+    }
+    if (m_RamData && m_Size > 0) {
+      cudaMemcpy(m_VramData, m_RamData, m_Size * sizeof(T),
+                 cudaMemcpyHostToDevice);
+    }
+#endif
+    m_Device = MemoryDevice::VRAM;
+  }
+
+  void resize(size_t size) {
+    if (m_Size == size)
+      return;
+
+    T *newRam = nullptr;
+    T *newVram = nullptr;
+
+    if (size > 0) {
+      if (m_OwnsObjects)
+        newRam = new T[size]();
+      else
+        newRam = static_cast<T *>(::operator new(size * sizeof(T)));
+
+      if (m_RamData) {
+        std::memcpy(newRam, m_RamData, std::min(m_Size, size) * sizeof(T));
+      }
+
+#ifdef USE_CUDA
+      cudaMalloc((void **)&newVram, size * sizeof(T));
+      if (m_VramData) {
+        cudaMemcpy(newVram, m_VramData, std::min(m_Size, size) * sizeof(T),
+                   cudaMemcpyDeviceToDevice);
+      }
+#endif
+    }
+
+    if (m_RamData) {
+      if (m_OwnsObjects)
+        delete[] m_RamData;
+      else
+        ::operator delete(m_RamData);
+    }
+#ifdef USE_CUDA
+    if (m_VramData)
+      cudaFree(m_VramData);
+#endif
+
+    m_Size = size;
+    m_RamData = newRam;
+    m_VramData = newVram;
+  }
+
+  size_t size() const { return m_Size; }
+
+  T &at(size_t index) {
+    MoveToRAM();
+    if (index >= m_Size)
+      throw std::out_of_range("Index out of range");
+    return m_RamData[index];
+  }
+
+  const T &at(size_t index) const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    if (index >= m_Size)
+      throw std::out_of_range("Index out of range");
+    return m_RamData[index];
+  }
+
+  T &operator[](size_t index) {
+    MoveToRAM();
+    return m_RamData[index];
+  }
+
+  const T &operator[](size_t index) const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    return m_RamData[index];
+  }
+
+  T *data() { return (m_Device == MemoryDevice::RAM) ? m_RamData : m_VramData; }
+  const T *data() const {
+    return (m_Device == MemoryDevice::RAM) ? m_RamData : m_VramData;
+  }
+
+  T *GetRAMData() { return m_RamData; }
+  const T *GetRAMData() const { return m_RamData; }
+
+  T *GetVRAMData() { return m_VramData; }
+  const T *GetVRAMData() const { return m_VramData; }
+
+  MemoryDevice GetDevice() const { return m_Device; }
+
+  // Iterator support for RAM operations
+  T *begin() {
+    MoveToRAM();
+    return m_RamData;
+  }
+  T *end() {
+    MoveToRAM();
+    return m_RamData + m_Size;
+  }
+  const T *begin() const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    return m_RamData;
+  }
+  const T *end() const {
+    const_cast<DataAllocator *>(this)->MoveToRAM();
+    return m_RamData + m_Size;
+  }
+
+private:
+  size_t m_Size;
+  T *m_RamData;
+  T *m_VramData;
+  MemoryDevice m_Device;
+  bool m_OwnsObjects;
+};
+
+} // namespace uLib
+
+#endif // U_MATH_DATAALLOCATOR_H
--- a/src/Core/Debug.h
+++ b/src/Core/Debug.h
@@ -29,12 +29,11 @@
 #define U_CORE_DEBUG_H


-
-#include "ltk/ltkdebug.h"
+#include <vector>
 #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;
-    Vector<Adapter>   m_a;
+    std::vector<DItem>     m_v;
+    std::vector<Adapter>   m_a;
 };


--- a/src/Core/Export.h
+++ b/src/Core/Export.h
@@ -23,95 +23,85 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_CORE_EXPORT_H
 #define U_CORE_EXPORT_H

-#include <utility>
 #include <cstddef> // NULL
 #include <iostream>
+#include <utility>

 #include <boost/config.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/preprocessor/stringize.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/type_traits/is_polymorphic.hpp>

-#include <boost/mpl/assert.hpp>
 #include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
+#include <boost/mpl/assert.hpp>
 #include <boost/mpl/bool.hpp>
+#include <boost/mpl/not.hpp>

-#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
-#include <boost/serialization/static_warning.hpp>
 #include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
 #include <boost/serialization/force_include.hpp>
 #include <boost/serialization/singleton.hpp>
+#include <boost/serialization/static_warning.hpp>

 #include <boost/archive/detail/register_archive.hpp>

-
 #include "Core/Archives.h"

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-
-
 namespace uLib {
 namespace Archive {
 namespace detail {
 namespace extra_detail {

-template<class T>
-struct guid_initializer
-{
-    void export_guid(mpl::false_) const {
+template <class T> struct guid_initializer {
+  void export_guid(boost::mpl::false_) const {
    // generates the statically-initialized objects whose constructors
    // register the information allowing serialization of T objects
    // through pointers to their base classes.
-        boost::archive::detail::
-                instantiate_ptr_serialization((T*)0, 0,
-                                              uLib::Archive::detail::adl_tag());
+    boost::archive::detail::instantiate_ptr_serialization(
+        (T *)0, 0, uLib::Archive::detail::adl_tag());
  }
-    void export_guid(mpl::true_) const {
-    }
-    guid_initializer const & export_guid() const {
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
+  void export_guid(boost::mpl::true_) const {}
+  guid_initializer const &export_guid() const {
+    BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
    // note: exporting an abstract base class will have no effect
    // and cannot be used to instantitiate serialization code
    // (one might be using this in a DLL to instantiate code)
-        //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
-        export_guid(boost::serialization::is_abstract< T >());
+    // BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
+    export_guid(boost::serialization::is_abstract<T>());
    return *this;
  }
 };

-template<typename T>
-struct init_guid;
+template <typename T> struct init_guid;

-} // anonymous
+} // namespace extra_detail
 } // namespace detail
 } // namespace Archive
 } // namespace uLib

-
-
 #define ULIB_CLASS_EXPORT_IMPLEMENT(T)                                         \
  namespace uLib {                                                             \
  namespace Archive {                                                          \
  namespace detail {                                                           \
  namespace extra_detail {                                                     \
-    template<>                                               \
-    struct init_guid< T > {                                  \
-        static guid_initializer< T > const & g;              \
+  template <> struct init_guid<T> {                                            \
+    static guid_initializer<T> const &g;                                       \
  };                                                                           \
-    guid_initializer< T > const & init_guid< T >::g =        \
+  guid_initializer<T> const &init_guid<T>::g =                                 \
      ::boost::serialization::singleton<                                       \
-            guid_initializer< T >                            \
-        >::get_mutable_instance().export_guid();             \
-    }}}}                                                     \
-/**/
+          guid_initializer<T>>::get_mutable_instance()                         \
+          .export_guid();                                                      \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  /**/

 #endif // EXPORT_H
--- a/src/Core/Makefile.am
+++ b/src/Core/Makefile.am
@@ -14,7 +14,6 @@ library_include_HEADERS = 	\
                                Macros.h \
                                Mpl.h \
                                Object.h \
-                                ObjectProps.h \
                                Options.h \
                                Serializable.h \
                                Signal.h \
--- a/src/Core/Object.cpp
+++ b/src/Core/Object.cpp
@@ -23,38 +23,29 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
-
-
 #include "config.h"

 #include "Object.h"
 #include "Vector.h"

-#include "boost/archive/polymorphic_xml_oarchive.hpp"
-#include "boost/archive/polymorphic_xml_iarchive.hpp"
-#include "boost/archive/polymorphic_text_oarchive.hpp"
-#include "boost/archive/polymorphic_text_iarchive.hpp"
-#include "boost/archive/polymorphic_binary_oarchive.hpp"
 #include "boost/archive/polymorphic_binary_iarchive.hpp"
-
-
+#include "boost/archive/polymorphic_binary_oarchive.hpp"
+#include "boost/archive/polymorphic_text_iarchive.hpp"
+#include "boost/archive/polymorphic_text_oarchive.hpp"
+#include "boost/archive/polymorphic_xml_iarchive.hpp"
+#include "boost/archive/polymorphic_xml_oarchive.hpp"

 namespace uLib {

-
 const char *Version::PackageName = PACKAGE_NAME;
 const char *Version::VersionNumber = PACKAGE_VERSION;
-const char *Version::Release       = "x"; //SVN_REVISION;
-
+const char *Version::Release = "x"; // SVN_REVISION;

 ////////////////////////////////////////////////////////////////////////////////
 // Object Private //

 class ObjectPrivate {
 public:
-
  struct Signal {
    GenericMFPtr sigptr;
    std::string sigstr;
@@ -66,135 +57,94 @@ public:
    std::string slostr;
  };

-
  Vector<Signal> sigv;
  Vector<Slot> slov;
 };

-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // OBJECT IMPLEMENTATION

+Object::Object() : d(new ObjectPrivate) {}

+Object::Object(const Object &copy) : d(new ObjectPrivate(*copy.d)) {}

-Object::Object() :
-    d(new ObjectPrivate)
-{}
+Object::~Object() { delete d; }

-Object::Object(const Object &copy) :
-    ObjectPropable(copy),
-    d(new ObjectPrivate(*copy.d))
-{}
-
-Object::~Object() {
-    delete d;
-}
-
-void Object::DeepCopy(const Object &copy)
-{
+void Object::DeepCopy(const Object &copy) {
  // should lock to be tread safe //
-    memcpy(d,copy.d,sizeof(ObjectPrivate));
+  memcpy(d, copy.d, sizeof(ObjectPrivate));
  // ERROR! does not copy parameters ... <<<< FIXXXXX
 }

-
-
-
-
-void Object::SaveXml(std::ostream &os, Object &ob)
-{
+void Object::SaveXml(std::ostream &os, Object &ob) {
  Archive::xml_oarchive ar(os);
-    ar << boost::serialization::make_nvp("Object",ob);
+  ar << boost::serialization::make_nvp("Object", ob);
 }

-void Object::LoadXml(std::istream &is, Object &ob)
-{
+void Object::LoadXml(std::istream &is, Object &ob) {
  Archive::xml_iarchive ar(is);
-    ar >> boost::serialization::make_nvp("Object",ob);
+  ar >> boost::serialization::make_nvp("Object", ob);
 }

-
 // FINIRE
-void Object::SaveConfig(std::ostream &os, int version)
-{   
+void Object::SaveConfig(std::ostream &os, int version) {
  Archive::xml_oarchive ar(os);
-    ObjectPropable::serialize(ar,0);
 }

-void Object::LoadConfig(std::istream &is, int version)
-{
-    if(!props()) this->init_properties();
+void Object::LoadConfig(std::istream &is, int version) {
  Archive::xml_iarchive ar(is);
-    ObjectPropable::serialize(ar,0);
 }

-
-
-
-
-void Object::PrintSelf(std::ostream &o) const
-{
+void Object::PrintSelf(std::ostream &o) const {
  o << "OBJECT signals: ------------------\n";
  Vector<ObjectPrivate::Signal>::Iterator itr;
-    for(itr = d->sigv.begin(); itr<d->sigv.end(); itr++)
-    {
+  for (itr = d->sigv.begin(); itr < d->sigv.end(); itr++) {
    o << "  signal:[ " << itr->sigstr << " ]\n";
  }
  o << "--------------------------------------\n\n";
 }

-
-bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name)
-{
-    ObjectPrivate::Signal s = {fptr,std::string(name),sig};
+bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
+                           const char *name) {
+  ObjectPrivate::Signal s = {fptr, std::string(name), sig};
  d->sigv.push_back(s);
+  return true;
 }

-bool Object::addSlotImpl(GenericMFPtr fptr, const char *name)
-{
-    ObjectPrivate::Slot s = {fptr,std::string(name)};
+bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) {
+  ObjectPrivate::Slot s = {fptr, std::string(name)};
  d->slov.push_back(s);
+  return true;
 }

-SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const
-{
-    for(int i=0; i<d->sigv.size(); ++i)
-    {
-        if(d->sigv[i].sigptr == fptr)
+SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const {
+  for (int i = 0; i < d->sigv.size(); ++i) {
+    if (d->sigv[i].sigptr == fptr)
      return d->sigv[i].signal;
  }
  return NULL;
 }

-SignalBase *Object::findSignalImpl(const char *name) const
-{
+SignalBase *Object::findSignalImpl(const char *name) const {
  std::string in(name);
-    for(int i=0; i<d->sigv.size(); ++i)
-    {
-        if(d->sigv[i].sigstr == in)
+  for (int i = 0; i < d->sigv.size(); ++i) {
+    if (d->sigv[i].sigstr == in)
      return d->sigv[i].signal;
  }
  return NULL;
 }

-GenericMFPtr *Object::findSlotImpl(const char *name) const
-{
+GenericMFPtr *Object::findSlotImpl(const char *name) const {
  std::string in(name);
-    for(int i=0; i<d->slov.size(); ++i)
-    {
-        if(d->slov[i].slostr == in)
+  for (int i = 0; i < d->slov.size(); ++i) {
+    if (d->slov[i].slostr == in)
      return &d->slov[i].sloptr;
  }
  return NULL;
 }

-
-
-
 // std::ostream &
 // operator << (std::ostream &os, uLib::Object &ob)
 // {
@@ -218,10 +168,4 @@ GenericMFPtr *Object::findSlotImpl(const char *name) const
 //     return is;
 // }

-
-
-
-} // uLib
-
-
-
+} // namespace uLib
--- a/src/Core/Object.h
+++ b/src/Core/Object.h
@@ -23,38 +23,33 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_CORE_OBJECT_H
 #define U_CORE_OBJECT_H

 #include <iostream>

 // WARNING: COPILE ERROR if this goes after mpl/vector //
-//#include "Core/Vector.h"
+// #include "Core/Vector.h"

-#include "Core/Types.h"
 #include "Core/Debug.h"
+#include "Core/Types.h"

 #include "Core/Function.h"
 #include "Core/Signal.h"

 #include "Core/Mpl.h"
 #include "Core/Serializable.h"
-#include "Core/ObjectProps.h"
 #include "Core/Uuid.h"

 namespace boost {
 namespace archive {
 class polymorphic_iarchive;
 class polymorphic_oarchive;
-} // archive
-} // boost
-
+} // namespace archive
+} // namespace boost

 namespace uLib {

-
 class Version {
 public:
  static const char *PackageName;
@@ -62,23 +57,14 @@ public:
  static const char *Release;
 };

-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 //// OBJECT ////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-
-
 /**
 * @brief Object class is the object base implementation for uLib Framework.
 */
-class Object : public ObjectPropable
-{
-
+class Object {

 public:
  //    std::string name;
@@ -94,14 +80,13 @@ public:
  // FIXX !!!
  virtual void DeepCopy(const Object &copy);

-
  ////////////////////////////////////////////////////////////////////////////
  // SERIALIZATION //

-    template <class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version)    {
-                ObjectPropable::serialize(ar,version);
-    }
-    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version) {}
+  template <class ArchiveT>
+  void serialize(ArchiveT &ar, const unsigned int version) {}
+  template <class ArchiveT>
+  void save_override(ArchiveT &ar, const unsigned int version) {}

  void SaveConfig(std::ostream &os, int version = 0);
  void LoadConfig(std::istream &is, int version = 0);
@@ -109,13 +94,12 @@ public:
  static void SaveXml(std::ostream &os, Object &ob);
  static void LoadXml(std::istream &is, Object &ob);

-
-
  ////////////////////////////////////////////////////////////////////////////
  // SIGNALS //

  // Qt4 style connector //
-    static bool connect(const Object *ob1, const char *signal_name, const Object *receiver, const char *slot_name) {
+  static bool connect(const Object *ob1, const char *signal_name,
+                      const Object *receiver, const char *slot_name) {
    //        // NOT WORKING YET //
    //        1) find slot pointer from name
    //        SignalBase   *sig = ob1->findSignal(signal_name);
@@ -123,78 +107,82 @@ public:
    //        if(sig && slo)
    //            return Object::connect(sig,slo->operator ()(),receiver);
    //        else return false;
+    return false;
  }

  // Qt5 style connector //
  template <typename Func1, typename Func2>
-    static bool connect( typename FunctionPointer<Func1>::Object *sender,   Func1 sigf,
-                         typename FunctionPointer<Func2>::Object *receiver, Func2 slof)
-    {
+  static bool
+  connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
+          typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
    SignalBase *sigb = sender->findOrAddSignal(sigf);
-        typedef boost::signals2::signal<typename FunctionPointer<Func2>::SignalSignature> SigT;
-        ConnectSignal(sigb,slof,receiver);
+    ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(sigb, slof,
+                                                                    receiver);
+    return true;
  }

  template <typename FuncT>
  static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
-        ConnectSignal(sigb,slof,receiver);
+    ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(sigb, slof,
+                                                                    receiver);
+    return true;
  }

-
-    template< typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
      addSignal(FuncT fun, const char *name) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
    SignalBase *sig = NewSignal(fun);
-        addSignalImpl(sig,fun,name);
+    addSignalImpl(sig, fun, name);
    return (SigT *)sig;
  }

-    template< typename FuncT>
-    inline bool addSlot(FuncT fun, const char *name) {
-        this->addSlotImpl(GenericMFPtr(fun),name);
+  template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) {
+    return this->addSlotImpl(GenericMFPtr(fun), name);
  }

-    template < typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    findSignal(FuncT fptr)
-    {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      findSignal(FuncT fptr) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
    return (SigT *)findSignalImpl(GenericMFPtr(fptr));
  }

-    template < typename FuncT >
-    inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
-    findOrAddSignal(FuncT fptr)
-    {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
+  template <typename FuncT>
+  inline
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
+      findOrAddSignal(FuncT fptr) {
+    typedef
+        typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
+            SigT;
    SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
-        if(!sig) {
+    if (!sig) {
      sig = NewSignal(fptr);
-            addSignalImpl(sig,fptr,"signal_name_to_be_implemented");
+      addSignalImpl(sig, fptr, "signal_name_to_be_implemented");
    }
    return (SigT *)sig;
  }

-
-    inline SignalBase *
-    findSignal(const char *name) const
-    {
+  inline SignalBase *findSignal(const char *name) const {
    return findSignalImpl(name);
  }

-    inline GenericMFPtr *
-    findSlot(const char *name) const
-    {
+  inline GenericMFPtr *findSlot(const char *name) const {
    return findSlotImpl(name);
  }

-
  void PrintSelf(std::ostream &o) const;

-    inline const Object& operator = (const Object &copy)
-    { this->DeepCopy(copy); return *this; }
-
+  inline const Object &operator=(const Object &copy) {
+    this->DeepCopy(copy);
+    return *this;
+  }

 private:
  bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
@@ -208,15 +196,12 @@ private:
  class ObjectPrivate *d;
 };

-
-
-} // uLib
+} // namespace uLib

 ////////////////////////////////////////////////////////////////////////////////

-//std::ostream & operator << (std::ostream &os, uLib::Object &ob);
-//std::ostream & operator << (std::ostream &os, uLib::Object *ob);
-//std::istream & operator >> (std::istream &is, uLib::Object &ob);
-
+// std::ostream & operator << (std::ostream &os, uLib::Object &ob);
+// std::ostream & operator << (std::ostream &os, uLib::Object *ob);
+// std::istream & operator >> (std::istream &is, uLib::Object &ob);

 #endif // U_OBJECT_H
--- a/src/Core/ObjectProps.h
+++ b/src/Core/ObjectProps.h
@@ -1,278 +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.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#ifndef U_OBJECTPROPS_H
-#define U_OBJECTPROPS_H
-
-
-
-#include <boost/algorithm/string/replace.hpp>
-
-#include <Core/Mpl.h>
-#include <Core/Types.h>
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// MACROS //
-
-
-#define ULIB_props() \
-    public: struct ObjectProps;		                               \
-    virtual void init_properties();                                \
-    inline struct ObjectProps &p() { /* static const unsigned int offset = props_offset(this); */ \
-    /* NON FUNZIA!  return * (struct ObjectProps *)(reinterpret_cast<char*>(props())+offset);  */ \
-    return *props()->ptr<ObjectProps>(); }                                                        \
-    typedef uLib::mpl::bool_<true>::type propable_trait;                                          \
-    public: struct DLL_PUBLIC ObjectProps
-
-#define properties() ULIB_props()
-
-#define default(vlaue)
-
-#define $$ p()
-
-#define $(_name) props_ref<_name>()
-
-#define $_init()                                                               \
-    if(props(this)) return;                                                    \
-    props_new(this);                                                           \
-    uLib::detail::ObjectProps::initializer::init_object_baselist(this);
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-namespace boost {
-namespace serialization {
-class access;
-}
-}
-
-
-namespace uLib {
-
-namespace detail {
-
-struct ObjectProps {
-
-    /** Define a trait has_member to find if an Object is Propable*/
-    BOOST_MPL_HAS_XXX_TRAIT_DEF(propable_trait)
-
-    /** IsA ProbapleObject Implementation Template */
-    template <class T>
-    struct IsA : has_propable_trait<T> {};
-
-    /** Lambda to get Props member type */
-    template <class T>
-    struct props_type {
-        typedef typename T::ObjectProps type;
-    };
-
-    template <typename T>
-    struct get_props {
-
-        /** CFList has result but this method check for has BaseList */
-        typedef typename detail::TypeIntrospection::child_first<T>::type CFTypeList;
-
-        /** Filter List items that have not Propable feature */
-        typedef typename mpl::filter_view< CFTypeList, IsA<mpl::_> >::type FilteredCFTypeList;
-
-        /** Get Props from each Parent in Seq */
-        typedef typename mpl::transform_view< FilteredCFTypeList, props_type<mpl::_> >::type type;
-
-
-        // qui sotto ho un problema che ho temporaneamente tamponato          //
-        // ovvero ho usato child_first_impl per ottenere la lista delle basi  //
-        // vorrei farlo facendo un pop_back ma non va forse perche il tipo    //
-        // non e' corretto. //
-
-        /** Get Parent list from CFTypeList */
-        typedef typename detail::TypeIntrospection::child_first_impl<T>::Childs CFBaseList;
-
-        /** Filter Parents that have not Propable feature */
-        typedef typename mpl::filter_view< CFBaseList, IsA<mpl::_> >::type FilteredCFBaseList;
-    };
-
-
-
-    // TODO: convert to pp const value,
-    // (non so se sia possibile con il dinamic casting intanto funziona cosi' )
-    template <typename T1, typename T2>
-    static unsigned int measure_offset(T1 base, T2 derived) {
-        return reinterpret_cast<char*>(derived) - reinterpret_cast<char*>(base);
-    }
-
-    struct initializer {
-
-        template <class _ObjectT>
-        struct lambda_init_object {
-            _ObjectT *o;
-            lambda_init_object(_ObjectT *o) : o(o) {}
-            template<class T> void operator()(T) {
-                o->T::init_properties();
-            }
-        };
-
-
-        /**
-         * This calls the internal init_properties() virtual function for each
-         * object parent defined in BaseList only if it is propable
-         */
-        template <class T>
-        static void init_object_baselist(T *o) {
-            typedef typename uLib::detail::ObjectProps::get_props<T>::FilteredCFBaseList CFBaseList;
-            mpl::for_each<CFBaseList>(lambda_init_object<T>(o));
-        }
-
-        /**
-         * This calls the internal init_properties() virtual function only if
-         * object is propable ( implementation if not propable )
-         */
-        template <class T>
-        static
-        typename boost::enable_if<mpl::not_<IsA<T> >,void>::type
-        init_object(T *o) {
-            ; // do nothing //
-        }
-
-        /**
-         * This calls the internal init_properties() virtual function only if
-         * object is propable ( implementation if propable )
-         */
-        template <class T>
-        static
-        typename boost::enable_if<IsA<T>,void>::type
-        init_object(T *o) {
-            o->init_properties();
-        }
-
-    };
-
-    template <class ThisClass, class Archive>
-    struct serialize_baselist {
-        ThisClass & m_object;
-        Archive   & m_ar;
-        serialize_baselist(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
-        template <class T> void operator()(T &o) {
-            // T is taken fron get_props<BaseList>::FilteredPList types to get
-            // type_info_name that is the type name defined by Type macro
-            typedef typename props_type<T>::type PType;
-            std::string name(TypeIntrospection::access<T>::type_info::name);
-            boost::algorithm::replace_all(name,"::","_");
-            m_ar & boost::serialization::make_nvp(
-                        name.c_str() ,
-                        boost::serialization::base_object<PType>(m_object));
-        }
-    };
-
-};
-
-} // detail
-
-
-
-
-
-struct ObjectPropsBase {
-    virtual ~ObjectPropsBase() {}
-    virtual ObjectPropsBase *copy() = 0;
-
-    template <class T> inline T *ptr() { return dynamic_cast<T*>(this); }
-
-    template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {}
-};
-
-
-
-template <class T>
-struct ObjectPropsImpl :
-        ObjectPropsBase,
-        ULIB_MPL_INHERIT_NOFOLD_SEQ(typename uLib::detail::ObjectProps::get_props<T>::type)
-{    
-    typedef ObjectPropsImpl<T> ThisClass;
-    typedef typename uLib::detail::ObjectProps::get_props<T>::type CFList;
-    typedef typename uLib::detail::ObjectProps::get_props<T>::FilteredCFTypeList FilteredCFTypeList;
-    ObjectPropsBase *copy() { return new ThisClass(*this); }
-
-    template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {
-        boost::serialization::void_cast_register<ThisClass,ObjectPropsBase>();
-        mpl::for_each<FilteredCFTypeList>(detail::ObjectProps::serialize_baselist<ThisClass,ArchiveT>(*this,ar));
-    }
-};
-
-
-class ObjectPropable {
-
-    ObjectPropsBase *m_props;
-    friend class uLib::detail::ObjectProps;
-    friend class boost::serialization::access;
-public:
-    ObjectPropable() : m_props(NULL) {}
-    ObjectPropable(const ObjectPropable &c) { if(c.m_props) m_props = c.m_props->copy(); else m_props = NULL; }
-    ~ObjectPropable() { if(m_props) delete m_props; }
-
-
-    template <class T> inline typename T::ObjectProps&  props_ref() const { if(m_props) return *m_props->ptr<typename T::ObjectProps>(); else exit(1); }
-    template <class T> inline typename T::ObjectProps*  props(T *ptr = NULL) const { if(m_props) return m_props->ptr<typename T::ObjectProps>(); else return NULL; }
-protected:
-    ObjectPropsBase *props() const { return m_props; }
-    template <class T> inline void props_new(T* ptr = NULL) { if(!m_props) m_props = new ObjectPropsImpl<T>; }
-
-    /** NOT working dynamic cache casting */
-    template <class T> inline unsigned int props_offset(T *ptr) const
-    { if(m_props) return detail::ObjectProps::measure_offset(m_props,m_props->ptr<T>()); else return -1; }
-
-
-    template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {
-        if(m_props) ar & boost::serialization::make_nvp("properties",m_props);
-    }
-
-public:
-    /**
-     * ObjectPropable is not directly propable itself to prevent Basclass
-     * duplication in inherit_nofold. And for the same reason ANY VIRTUAL BASE
-     * SHOULD NOT BE PROPABLE
-     */
-    virtual void init_properties() {}
-
-};
-
-} // uLib
-
-
-
-
-
-
-
-#endif // U_OBJECTPROPS_H
--- a/src/Core/Options.cpp
+++ b/src/Core/Options.cpp
@@ -31,6 +31,9 @@

 #include <boost/program_options.hpp>

+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/ini_parser.hpp>
+

 //class boost::program_options::error_with_option_name;
 //template<> boost::program_options::typed_value<int> boost::program_options::value<int>();
@@ -74,6 +77,23 @@ void Options::parse_config_file(const char *fname)
    }
 }

+void Options::save_config_file(const char *fname) {
+    std::ofstream os;
+    os.open(fname);
+    
+    using boost::property_tree::ptree;
+
+    ptree root;
+
+
+    std::cout << m_configuration << "\n";
+    std::cout << m_global << "\n";
+
+    write_ini( std::cout, root );
+
+}
+
+
 bool Options::count(const char *str) const
 {
    return (m_vm.count(str));
--- a/src/Core/Options.h
+++ b/src/Core/Options.h
@@ -160,6 +160,8 @@ public:

    void parse_config_file(const char *fname);

+    void save_config_file(const char *fname);
+
    template <typename T>
    static inline boost::program_options::typed_value<T>* value(T *v, T dvalue) {
        boost::program_options::typed_value<T> *r = boost::program_options::value<T>(v);
--- a/src/Core/Serializable.h
+++ b/src/Core/Serializable.h
@@ -23,8 +23,6 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_SERIALIZABLE_H
 #define U_SERIALIZABLE_H

@@ -38,9 +36,6 @@ TODO:

 */

-
-
-
 #include <boost/serialization/access.hpp>
 #include <boost/serialization/export.hpp>

@@ -48,26 +43,22 @@ TODO:
 #include <boost/mpl/remove_if.hpp>
 #include <boost/serialization/nvp.hpp>

-//#include <boost/archive/xml_iarchive.hpp>
-//#include <boost/archive/xml_oarchive.hpp>
-//#include <boost/archive/text_iarchive.hpp>
-//#include <boost/archive/text_oarchive.hpp>
-//#include "boost/archive/polymorphic_iarchive.hpp"
-//#include "boost/archive/polymorphic_oarchive.hpp"
+// #include <boost/archive/xml_iarchive.hpp>
+// #include <boost/archive/xml_oarchive.hpp>
+// #include <boost/archive/text_iarchive.hpp>
+// #include <boost/archive/text_oarchive.hpp>
+// #include "boost/archive/polymorphic_iarchive.hpp"
+// #include "boost/archive/polymorphic_oarchive.hpp"

-#include <boost/preprocessor/comma_if.hpp>
-#include <boost/preprocessor/repeat.hpp>
-#include <boost/preprocessor/inc.hpp>
 #include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/comma_if.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/repeat.hpp>
 #include <boost/preprocessor/tuple/to_seq.hpp>

-
-#include "Core/Mpl.h"
-#include "Core/ObjectProps.h"
 #include "Core/Archives.h"
 #include "Core/Export.h"
-
-
+#include "Core/Mpl.h"

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -80,28 +71,20 @@ namespace serialization {
 // ACCESS 2 //
 template <class T> struct access2 {};

-
 // NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
-template<class T>
-class hrp :
-        public wrapper_traits<const hrp< T > >
-{
+template <class T> class hrp : public wrapper_traits<const hrp<T>> {
  const char *m_name;
  T *m_value;
  std::string *m_str;

 public:
-    explicit hrp(const char * name_, T &t) :
-        m_str(new std::string),
-        m_name(name_), m_value(&t) {}
+  explicit hrp(const char *name_, T &t)
+      : m_str(new std::string), m_name(name_), m_value(&t) {}

-    const char * name() const {
-        return this->m_name;
-    }
+  const char *name() const { return this->m_name; }

-
-    template<class Archivex>
-    void save( Archivex & ar, const unsigned int /* file_version */) const {
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* file_version */) const {
    ////        ar.operator<<(const_value());
    //        std::stringstream ss;
    //        uLib::Archive::hrt_oarchive har(ss);
@@ -109,34 +92,26 @@ public:
    //        //        (*m_str) = ss.str();
    ////        ar.operator << (make_nvp(m_name, ss.str());
  }
-    template<class Archivex>
-    void load( Archivex & ar, const unsigned int /* file_version */) {
-//        ar.operator>>(value());
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* file_version */) {
+    //        ar.operator>>(value());
  }
  BOOST_SERIALIZATION_SPLIT_MEMBER()
 };

-
-template<class T>
+template <class T>
 inline
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-const
+    const
 #endif
-hrp< T > make_hrp(const char * name, T & t){
-    return hrp< T >(name, t);
+    hrp<T> make_hrp(const char *name, T &t) {
+  return hrp<T>(name, t);
 }

-#define HRP(name) \
-    boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
-
-
-} // serialization
-} // boost
-
-
-
-
+#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)

+} // namespace serialization
+} // namespace boost

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -151,9 +126,7 @@ hrp< T > make_hrp(const char * name, T & t){

 namespace uLib {

-
-
-#define _AR_OP(r,data,elem) data&BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
+#define _AR_OP(r, data, elem) data &BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);

 #define NVP(data) BOOST_SERIALIZATION_NVP(data)

@@ -166,23 +139,26 @@ namespace uLib {
 // SO LEAVE ULIB_CFG_INTRUSIVE_SERIALIZATION NOT DEFINED

 #ifdef ULIB_CFG_INTRUSIVE_SERIALIZATION_OBJECT
-#  define ULIB_SERIALIZABLE_OBJECT        _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
-#  define ULIB_SERIALIZE_OBJECT(_Ob,...)  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
-#  define _AR_(_name)                     _ULIB_DETAIL_INTRUSIVE_AR_(_name)
+#define ULIB_SERIALIZABLE_OBJECT _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
+#define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
+  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
+#define _AR_(_name) _ULIB_DETAIL_INTRUSIVE_AR_(_name)
 #else
-#  define ULIB_SERIALIZABLE(_Ob)           _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
+#define ULIB_SERIALIZABLE(_Ob)                                                 \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob)                                   \
  ULIB_CLASS_EXPORT_KEY(_Ob)
-#  define ULIB_SERIALIZE(_Ob,...)          _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)
-#  define ULIB_SERIALIZE_DERIVED(_Ob,...)  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,__VA_ARGS__)
-#  define ULIB_SERIALIZABLE_OBJECT(_Ob)    _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
+#define ULIB_SERIALIZE(_Ob, ...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)
+#define ULIB_SERIALIZE_DERIVED(_Ob, ...)                                       \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, __VA_ARGS__)
+#define ULIB_SERIALIZABLE_OBJECT(_Ob)                                          \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob)                            \
  ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
-#  define ULIB_SERIALIZE_OBJECT(_Ob,...)   _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
-#  define ULIB_SERIALIZE_OBJECT_PROPS(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob)
-#  define AR(_name)                        _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
-#  define HR(_name)                        _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
+#define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
+#define AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
+#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
 #endif

-
 #define ULIB_SERIALIZE_ACCESS                                                  \
  friend class boost::serialization::access;                                   \
  template <class T> friend class boost::serialization::access2;
@@ -191,26 +167,25 @@ namespace uLib {
  BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)

 #define ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass)                      \
-    BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)                      \
-    BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass::ObjectProps)         \
-    BOOST_CLASS_EXPORT_KEY(uLib::ObjectPropsImpl<_FullNamespaceClass>)
-
+  BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)

 #define _SERIALIZE_IMPL_SEQ                                                                   \
-    (uLib::Archive::text_iarchive) \
-    (uLib::Archive::text_oarchive) \
-    (uLib::Archive::hrt_iarchive)  \
-    (uLib::Archive::hrt_oarchive)  \
-    (uLib::Archive::xml_iarchive)  \
-    (uLib::Archive::xml_oarchive)  \
-    (uLib::Archive::log_archive)
-
+  (uLib::Archive::text_iarchive)(uLib::Archive::text_oarchive)(                               \
+      uLib::Archive::                                                                         \
+          hrt_iarchive)(uLib::Archive::                                                       \
+                            hrt_oarchive)(uLib::Archive::                                     \
+                                              xml_iarchive)(uLib::Archive::                   \
+                                                                xml_oarchive)(uLib::Archive:: \
+                                                                                  log_archive)

 /** Solving virtual class check problem */
-#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base,_Derived)    namespace boost{ template<> struct is_virtual_base_of<_Base,_Derived>: public boost::mpl::true_ {}; }
-#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r,data,elem) _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem,data)
-
-
+#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived)               \
+  namespace boost {                                                            \
+  template <>                                                                  \
+  struct is_virtual_base_of<_Base, _Derived> : public boost::mpl::true_ {};    \
+  }
+#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r, data, elem)              \
+  _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem, data)

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -220,38 +195,57 @@ namespace uLib {
 ////////////////////////////////////////////////////////////////////////////////
 // INTRUSIVE SERIALIZATION ( NOT WORKING YET !! ) //

-#define _ULIB_DETAIL_INTRUSIVE_AR_(name) ar & BOOST_SERIALIZATION_NVP(name);
+#define _ULIB_DETAIL_INTRUSIVE_AR_(name) ar &BOOST_SERIALIZATION_NVP(name);

-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class,Archive) \
-    template void Class::serialize(Archive &ar,const unsigned int);
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class, Archive)                  \
+  template void Class::serialize(Archive &ar, const unsigned int);

-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r,data,elem) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data,elem);
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem)                \
+  _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data, elem);

 #define _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT                             \
  typedef boost::mpl::bool_<true> serializable;                                \
-    typedef boost::mpl::remove_if< TypeList, IsUnSerializable >::type SerilizableTypeList;       \
-    void PrintSerializableListId() { boost::mpl::for_each<SerilizableTypeList>(PrintTypeId()); } \
-    template <class ArchiveT> void serialize(ArchiveT &ar,const unsigned int version);           \
-    template <class ArchiveT> void serialize_parents(ArchiveT &ar,const unsigned int version);   \
-    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version);
+  typedef boost::mpl::remove_if<TypeList, IsUnSerializable>::type              \
+      SerilizableTypeList;                                                     \
+  void PrintSerializableListId() {                                             \
+    boost::mpl::for_each<SerilizableTypeList>(PrintTypeId());                  \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, const unsigned int version);                    \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, const unsigned int version);            \
+  template <class ArchiveT>                                                    \
+  void save_override(ArchiveT &ar, const unsigned int version);

-#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,...) \
-    template <class ArchiveT> void _Ob::serialize(ArchiveT &ar, const unsigned int version) { \
-    boost::serialization::void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL));   \
-    _Ob::serialize_parents(ar,version); \
-    _Ob::save_override(ar,version); }\
-    template <class ArchiveT> void _Ob::serialize_parents(ArchiveT &ar, const unsigned int v) { \
-    BOOST_PP_SEQ_FOR_EACH(_AR_OP,ar,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); } \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
+#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, ...)                      \
+  template <class ArchiveT>                                                    \
+  void _Ob::serialize(ArchiveT &ar, const unsigned int version) {              \
+    boost::serialization::void_cast_register<_Ob, _Ob::BaseClass>(             \
+        static_cast<_Ob *>(NULL), static_cast<_Ob::BaseClass *>(NULL));        \
+    _Ob::serialize_parents(ar, version);                                       \
+    _Ob::save_override(ar, version);                                           \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void _Ob::serialize_parents(ArchiveT &ar, const unsigned int v) {            \
+    BOOST_PP_SEQ_FOR_EACH(_AR_OP, ar, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));   \
+  }                                                                            \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP, _Ob,         \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob,       \
+                        BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))                  \
  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
  namespace boost {                                                            \
  namespace serialization {                                                    \
-    template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *o, const unsigned int file_version) \
-    { ::new(o)_Ob(); o->init_parameters(); } }}\
-    template <class ArchiveT> void _Ob::save_override(ArchiveT &ar, const unsigned int version)
-
-
+  template <class ArchiveT>                                                    \
+  inline void load_construct_data(ArchiveT &ar, _Ob *o,                        \
+                                  const unsigned int file_version) {           \
+    ::new (o) _Ob();                                                           \
+    o->init_parameters();                                                      \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void _Ob::save_override(ArchiveT &ar, const unsigned int version)

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -261,96 +255,134 @@ namespace uLib {
 ////////////////////////////////////////////////////////////////////////////////
 // UNINTRUSIVE SERIALIZATION

-#define _UNAR_OP(r,data,elem) ar&boost::serialization::make_nvp(BOOST_PP_STRINGIZE(elem),boost::serialization::base_object<elem>(ob));
+#define _UNAR_OP(r, data, elem)                                                \
+  ar &boost::serialization::make_nvp(                                          \
+      BOOST_PP_STRINGIZE(elem), boost::serialization::base_object<elem>(ob));

-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class,Archive) \
-    template void boost::serialization::serialize(Archive &ar, Class &ob, const unsigned int i);
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP(r,data,elem) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data,elem)
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class, Archive)                \
+  template void boost::serialization::serialize(Archive &ar, Class &ob,        \
+                                                const unsigned int i);

+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem)              \
+  _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data, elem)

 // NOTE: becouse of BOOST_PP_VARIADIC_SIZE issue of some boost macro has two
 // different implementation

 #define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob)                             \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize         (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; }}
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version);           \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int version);   \
+  template <> struct access2<_Ob> {                                            \
+    template <class ArchiveT>                                                  \
+    static void save_override(ArchiveT &ar, _Ob &ob,                           \
+                              const unsigned int version);                     \
+  };                                                                           \
+  }                                                                            \
+  }

 #define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)                                \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {} \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
-    serialize_parents(ar,ob,version);  \
-    access2< _Ob >::save_override(ar,ob,version); } }}\
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {}       \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) {          \
+    serialize_parents(ar, ob, version);                                        \
+    access2<_Ob>::save_override(ar, ob, version);                              \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
-    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob,       \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  template <class ArchiveT>                                                    \
+  void boost::serialization::access2<_Ob>::save_override(                      \
+      ArchiveT &ar, _Ob &ob, const unsigned int version)

-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,...) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
-    BOOST_PP_IF(BOOST_PP_VARIADIC_SIZE((__VA_ARGS__)),BOOST_PP_SEQ_FOR_EACH(_UNAR_OP,ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));,) } \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
-    serialize_parents(ar,ob,version);  \
-    access2< _Ob >::save_override    (ar,ob,version); } }}\
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, ...)                   \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {        \
+    BOOST_PP_IF(BOOST_PP_VARIADIC_SIZE((__VA_ARGS__)),                         \
+                BOOST_PP_SEQ_FOR_EACH(_UNAR_OP, ob,                            \
+                                      BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));   \
+                , )                                                            \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) {          \
+    serialize_parents(ar, ob, version);                                        \
+    access2<_Ob>::save_override(ar, ob, version);                              \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ) \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
-    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
-
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob,       \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob,       \
+                        BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))                  \
+  template <class ArchiveT>                                                    \
+  void boost::serialization::access2<_Ob>::save_override(                      \
+      ArchiveT &ar, _Ob &ob, const unsigned int version)

 #define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob)                      \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize         (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
-    template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; \
-    template <class ArchiveT> void serialize         (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); \
-    template <class ArchiveT> void save_override     (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); }}
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version);           \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int version);   \
+  template <> struct access2<_Ob> {                                            \
+    template <class ArchiveT>                                                  \
+    static void save_override(ArchiveT &ar, _Ob &ob,                           \
+                              const unsigned int version);                     \
+  };                                                                           \
+  }                                                                            \
+  }

-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,...) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
-    /* PP  serialize */ BOOST_PP_SEQ_FOR_EACH(_UNAR_OP,ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); \
+#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, ...)                    \
+  namespace boost {                                                            \
+  namespace serialization {                                                    \
+  template <class ArchiveT>                                                    \
+  void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {        \
+    /* PP  serialize */ BOOST_PP_SEQ_FOR_EACH(                                 \
+        _UNAR_OP, ob, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));                   \
  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }                                                          \
-    template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *ob, const unsigned int file_version) { \
-    ::new(ob)_Ob(); uLib::detail::ObjectProps::initializer::init_object(ob); } \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
-    void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL)); /*fix*/  \
-    serialize_parents(ar,ob,version);  \
-    access2< _Ob >::save_override    (ar,ob,version); } }}\
+  template <class ArchiveT>                                                    \
+  inline void load_construct_data(ArchiveT &ar, _Ob *ob,                       \
+                                  const unsigned int file_version) {           \
+    ::new (ob) _Ob();                                                          \
+  }                                                                            \
+  template <class ArchiveT>                                                    \
+  void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) {          \
+    void_cast_register<_Ob, _Ob::BaseClass>(                                   \
+        static_cast<_Ob *>(NULL),                                              \
+        static_cast<_Ob::BaseClass *>(NULL)); /*fix*/                          \
+    serialize_parents(ar, ob, version);                                        \
+    access2<_Ob>::save_override(ar, ob, version);                              \
+  }                                                                            \
+  }                                                                            \
+  }                                                                            \
  ULIB_CLASS_EXPORT_IMPLEMENT(_Ob)                                             \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
-    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
-
-#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob) \
-    namespace boost { namespace serialization { \
-    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob::ObjectProps &ob, const unsigned int version) { \
-    save_override    (ar,ob,version); } }}\
-    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob::ObjectProps,_SERIALIZE_IMPL_SEQ)\
-    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob::ObjectProps) \
-    ULIB_CLASS_EXPORT_IMPLEMENT(uLib::ObjectPropsImpl<_Ob>) \
-    template <class ArchiveT> void boost::serialization::save_override(ArchiveT &ar, _Ob::ObjectProps &ob, const unsigned int version)
-
-
-#define _ULIB_DETAIL_UNINTRUSIVE_AR_(name) boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name),ob.name)
-
-
-
-
-
-
-
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob,       \
+                        BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))                  \
+  BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob,       \
+                        _SERIALIZE_IMPL_SEQ)                                   \
+  template <class ArchiveT>                                                    \
+  void boost::serialization::access2<_Ob>::save_override(                      \
+      ArchiveT &ar, _Ob &ob, const unsigned int version)

+#define _ULIB_DETAIL_UNINTRUSIVE_AR_(name)                                     \
+  boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), ob.name)

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-
-
 namespace detail {

 struct Serializable {
@@ -360,53 +392,34 @@ struct Serializable {
   * This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
   * cases a has_serialize trait should be implemented
   */
-    template <class T>
-    struct serializable_trait : mpl::bool_<false> {};
+  template <class T> struct serializable_trait : mpl::bool_<false> {};

  /**
   * IsA Serializable Implementation Template
   */
-    template <class T>
-    struct IsA : serializable_trait<T> {};
+  template <class T> struct IsA : serializable_trait<T> {};

-    template <class ThisClass, class Archive>
-    struct serialize_baseobject {
-        ThisClass & m_object;
-        Archive   & m_ar;
+  template <class ThisClass, class Archive> struct serialize_baseobject {
+    ThisClass &m_object;
+    Archive &m_ar;
    serialize_baseobject(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
    template <class T> void operator()(T &o) {
-            m_ar & boost::serialization::make_nvp(
-                        typeid(T).name() ,
-                        boost::serialization::base_object<T>(m_object));
+      m_ar &boost::serialization::make_nvp(
+          typeid(T).name(), boost::serialization::base_object<T>(m_object));
    }
  };
-
-
 };

-
-} // detail
-
-
-
-
+} // namespace detail

 struct Serializable {
  friend class boost::serialization::access;
  template <class T> friend class boost::serialization::access2;
  virtual ~Serializable() {}
+
 protected:
 };

-
-
-
-
-} // uLib
-
-
-
-
-
+} // namespace uLib

 #endif // U_SERIALIZABLE_H
--- a/src/Core/Signal.h
+++ b/src/Core/Signal.h
@@ -23,21 +23,19 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_CORE_SIGNAL_H
 #define U_CORE_SIGNAL_H

 #include <boost/typeof/typeof.hpp>

 #include <boost/signals2/signal.hpp>
-#include <boost/signals2/slot.hpp>
 #include <boost/signals2/signal_type.hpp>
+#include <boost/signals2/slot.hpp>

 #include "Function.h"
+#include <boost/bind/bind.hpp>

-
-
+using namespace boost::placeholders;

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -51,9 +49,12 @@
 #define SLOT(a) BOOST_STRINGIZE(a)
 #define SIGNAL(a) BOOST_STRINGIZE(a)

-#define _ULIB_DETAIL_SIGNAL_EMIT(_name,...)                       \
-        static BOOST_AUTO(sig,this->findOrAddSignal(&_name));     \
-        sig->operator()(__VA_ARGS__);
+#define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...)                                   \
+  do {                                                                         \
+    BOOST_AUTO(sig, this->findOrAddSignal(&_name));                            \
+    if (sig)                                                                   \
+      sig->operator()(__VA_ARGS__);                                            \
+  } while (0)

 /**
 * Utility macro to implement signal emission implementa una delle seguenti:
@@ -66,103 +67,101 @@
 * // cast automatico //
 * static BOOST_AUTO(sig,this->findOrAddSignal(&Ob1::V0));
 *   sig->operator()();
-*/
-#define ULIB_SIGNAL_EMIT(_name,...) _ULIB_DETAIL_SIGNAL_EMIT(_name,__VA_ARGS__)
-
+ */
+#define ULIB_SIGNAL_EMIT(_name, ...)                                           \
+  _ULIB_DETAIL_SIGNAL_EMIT(_name, __VA_ARGS__)

 namespace uLib {

-
 // A boost::signal wrapper structure ///////////////////////////////////////////

 // TODO ...

 typedef boost::signals2::signal_base SignalBase;

-template <typename T>
-struct Signal {
+template <typename T> struct Signal {
  typedef boost::signals2::signal<T> type;
 };

-
-
 ////////////////////////////////////////////////////////////////////////////////

-
 namespace detail {

-
-template <typename FuncT, int arity>
+template <typename FuncT, typename SigSignature, int arity>
 struct ConnectSignal {};

-template <typename FuncT>
-struct ConnectSignal< FuncT, 0 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(slof);
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 0> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(slof);
  }
 };

-template <typename FuncT>
-struct ConnectSignal< FuncT, 1 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver));
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 1> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
  }
 };

-template <typename FuncT>
-struct ConnectSignal< FuncT, 2 > {
-    static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1));
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 2> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
  }
 };

-template <typename FuncT>
-struct ConnectSignal< FuncT, 3 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2));
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 3> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2));
  }
 };

-template <typename FuncT>
-struct ConnectSignal< FuncT, 4 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3));
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 4> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3));
  }
 };

-template <typename FuncT>
-struct ConnectSignal< FuncT, 5 > {
-    static void connect(SignalBase *sigb, FuncT slof,  typename FunctionPointer<FuncT>::Object *receiver) {
-        typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
-        reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3,_4));
+template <typename FuncT, typename SigSignature>
+struct ConnectSignal<FuncT, SigSignature, 5> {
+  static void connect(SignalBase *sigb, FuncT slof,
+                      typename FunctionPointer<FuncT>::Object *receiver) {
+    typedef typename Signal<SigSignature>::type SigT;
+    reinterpret_cast<SigT *>(sigb)->connect(
+        boost::bind(slof, receiver, _1, _2, _3, _4));
  }
 };

+} // namespace detail

-} // detail
-
-
-
-template <typename FuncT>
-SignalBase *NewSignal(FuncT f) {
-    // seems to work wow !
-    return new Signal<void()>::type;
+template <typename FuncT> SignalBase *NewSignal(FuncT f) {
+  return new
+      typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type;
 }

-template <typename FuncT>
-void ConnectSignal(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver)
-{
-    detail::ConnectSignal< FuncT, FunctionPointer<FuncT>::arity >::connect(sigb,slof,receiver);
+template <typename SigSignature, typename FuncT>
+void ConnectSignal(SignalBase *sigb, FuncT slof,
+                   typename FunctionPointer<FuncT>::Object *receiver) {
+  detail::ConnectSignal<FuncT, SigSignature,
+                        FunctionPointer<FuncT>::arity>::connect(sigb, slof,
+                                                                receiver);
 }

-
-
-
-} // uLib
+} // namespace uLib

 #endif // SIGNAL_H
--- a/src/Core/StringReader.h
+++ b/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>

--- a/src/Core/Types.h
+++ b/src/Core/Types.h
@@ -23,8 +23,6 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_CORE_TYPES_H
 #define U_CORE_TYPES_H

@@ -33,20 +31,13 @@

 #include <boost/preprocessor.hpp>

-#include <ltk/ltktypes.h>
+// #include <ltk/ltktypes.h>

 #include "Core/Macros.h"
 #include "Core/Mpl.h"

-
-
-
-
-
-
 namespace uLib {

-
 ////////////////////////////////////////////////////////////////////////////////

 namespace detail {
@@ -72,23 +63,19 @@ struct TypeIntrospection {
  */

  /** IsA Introspectable Object Implementation Template */
-    template <class T>
-    struct IsIntrospectable : has_type_info<T> {};
+  template <class T> struct IsIntrospectable : has_type_info<T> {};

  template <typename T> struct access {
    typedef typename T::type_info type_info;
  };

-    template <typename T>
-    struct child_first_impl {
+  template <typename T> struct child_first_impl {

-        template <class T1, bool cond>
-        struct lambda_CFList_f {
+    template <class T1, bool cond> struct lambda_CFList_f {
      typedef mpl::vector<T1> type;
    };

-        template <class T1>
-        struct lambda_CFList_f<T1,true> {
+    template <class T1> struct lambda_CFList_f<T1, true> {
      //            typedef typename T1::type_info::CFList type;
      typedef typename access<T1>::type_info::CFList type;
    };
@@ -97,75 +84,60 @@ struct TypeIntrospection {
    struct lambda_CFList : lambda_CFList_f<T1, has_type_info<T1>::value> {};

    /** Transforms all Base Type into proper CFList */
-        typedef typename mpl::transform_view < typename access<T>::type_info::BaseList
-                                             , lambda_CFList<mpl::_>
-                                             >::type CFListSeq;
+    typedef
+        typename mpl::transform_view<typename access<T>::type_info::BaseList,
+                                     lambda_CFList<mpl::_>>::type CFListSeq;

    /** Folds each CFList into a new sequence */
-        typedef typename mpl::fold< CFListSeq
-                                  , mpl::vector<>
-                                  , mpl::copy< mpl::_1
-                                             , mpl::back_inserter<mpl::_2>
-                                             >
-                                  >::type Childs;
+    typedef typename mpl::fold<
+        CFListSeq, mpl::vector<>,
+        mpl::copy<mpl::_1, mpl::back_inserter<mpl::_2>>>::type Childs;

    /** Add This Class to final CFList sequence */
-        typedef typename mpl::copy< Childs
-                                  , mpl::back_inserter< mpl::vector<T> >
-                                  >::type type;
+    typedef typename mpl::copy<Childs, mpl::back_inserter<mpl::vector<T>>>::type
+        type;
  };

-
  /**
   * Tests if T has a member called type_info then compile type CFList
   */
  template <typename T>
-    struct child_first : mpl::if_< has_type_info<T>
-                                 , child_first_impl<T>
-                                 , mpl::vector<>
-                                 >::type {};
-
-
+  struct child_first
+      : mpl::if_<has_type_info<T>, child_first_impl<T>, mpl::vector<>>::type {};
 };

-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // TYPE ADAPTERS // FINIRE !!!

-//#define _REPETITION_V(vz,vn,vdata)
+// #define _REPETITION_V(vz,vn,vdata)

-
-//template < class TypeList >
-//class TypeAdapterInputInterface {
+// template < class TypeList >
+// class TypeAdapterInputInterface {
 //     virtual ~TypeAdapterInputInterface() {}
-//public:
-
-
+// public:

 //    virtual void operator()(int val)         {}
 //    virtual void operator()(std::string val) {}
 //};

-
-
-
-
-
-
-} // detail ////////////////////////////////////////////////////////////////////
-
+} // namespace detail

 #define CONSTEXPR BOOST_CONSTEXPR

-
-typedef ltk::Real_t      Real_t;
-typedef ltk::Id_t        Id_t;
-//typedef ltk::Size_t      Size_t;
-typedef ltk::Pointer_t   Pointer_t;
-typedef bool             Bool_t;      //Boolean (0=false, 1=true) (bool)
+// typedef ltk::Real_t      Real_t;
+#ifndef LTK_DOUBLE_PRECISION
+typedef float Real_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
@@ -173,104 +145,68 @@ typedef bool             Bool_t;      //Boolean (0=false, 1=true) (bool)
 #endif

 #ifndef SETBIT
-#define SETBIT(n,i)  ((n) |= BIT(i))
+#define SETBIT(n, i) ((n) |= BIT(i))
 #endif

 #ifndef CLRBIT
-#define CLRBIT(n,i)  ((n) &= ~BIT(i))
+#define CLRBIT(n, i) ((n) &= ~BIT(i))
 #endif

 #ifndef TESTBIT
-#define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
+#define TESTBIT(n, i) ((Bool_t)(((n) & BIT(i)) != 0))
 #endif

-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // TYPE INTROSPECTION FOR OBJECTS //

-
-
-#define uLibTypeMacro(thisClass,...) \
+#define uLibTypeMacro(thisClass, ...)                                          \
                                                                               \
  /* Friendship detail for accessing introspection */                          \
  template <typename> friend class uLib::detail::TypeIntrospection::access;    \
                                                                               \
-    /* type info structure*/ public: \
+/* type info structure*/ public:                                               \
  /* in GCC 4.8 must be public or dynamic_cast wont work */                    \
  struct type_info {                                                           \
    /*WARNING: -std=c++0x required for this! */                                \
    constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass);         \
-      typedef BOOST_PP_VARIADIC_ELEM(0,__VA_ARGS__) BaseClass;                      \
+    typedef BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) BaseClass;                  \
    typedef thisClass ThisClass;                                               \
-      typedef uLib::mpl::vector<__VA_ARGS__,thisClass> TypeList;                    \
+    typedef uLib::mpl::vector<__VA_ARGS__, thisClass> TypeList;                \
    typedef uLib::mpl::vector<__VA_ARGS__> BaseList;                           \
-      typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type CFList; \
+    typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type      \
+        CFList;                                                                \
  };                                                                           \
                                                                               \
-    public: \
+public:                                                                        \
  typedef type_info::BaseClass BaseClass;                                      \
  virtual const char *type_name() const { return type_info::name; }            \
-    /* Object Props fwd declaration*/ \
-    struct ObjectProps; \
  /**/

-
 /**
 * TypeList inheritance introspection
 */
 struct TypeIntrospection {
  template <typename T>
  struct child_first : detail::TypeIntrospection::child_first<T> {};
-
 };

-
-
-
-
-
 // SISTEMARE //
 struct PrintTypeId {
-    template <class T>
-    void operator()(T) const
-    { std::cout << typeid(T).name() << std::endl; }
+  template <class T> void operator()(T) const {
+    std::cout << typeid(T).name() << std::endl;
+  }

-    template <typename SeqT>
-    static void PrintMplSeq(SeqT *p = NULL) { boost::mpl::for_each<SeqT>(PrintTypeId()); }
+  template <typename SeqT> static void PrintMplSeq(SeqT *p = NULL) {
+    boost::mpl::for_each<SeqT>(PrintTypeId());
+  }

-    template <typename Class>
-    static void PrintType(Class *p = NULL) { std::cout << typeid(Class).name() << std::endl; }
+  template <typename Class> static void PrintType(Class *p = NULL) {
+    std::cout << typeid(Class).name() << std::endl;
+  }
 };

-
-
-
-
-
-
-} // uLib
+} // namespace uLib

 #endif // U_CORE_TYPES_H
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
--- a/src/Core/Uuid.h
+++ b/src/Core/Uuid.h
@@ -23,59 +23,42 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_CORE_UUID_H
 #define U_CORE_UUID_H

 #include <iostream>
+#include <vector>

-#include <boost/uuid/uuid.hpp>
 #include <boost/uuid/name_generator.hpp>
 #include <boost/uuid/random_generator.hpp>
+#include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_io.hpp>

 #include "Core/Mpl.h"
-#include "Core/Vector.h"
 #include "Core/Object.h"

-
 namespace uLib {

-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // Object Registration //

-
 typedef boost::uuids::uuid uuid_t;

 extern uuid_t uLib_dns_uuid;

-template < typename T >
-class type_id : public boost::uuids::uuid {
+template <typename T> class type_id : public boost::uuids::uuid {
 public:
-    type_id() :
-        m_size(sizeof(T)),
-        uuid(boost::uuids::name_generator(uLib_dns_uuid)(typeid(T).name()))
-    {
-        std::cout << "Request for register new type\n" <<
-                     "name: " << typeid(T).name() << "\n" <<
-                     "uuid: " << to_string(*this) << "\n";
+  type_id()
+      : m_size(sizeof(T)),
+        uuid(boost::uuids::name_generator(uLib_dns_uuid)(typeid(T).name())) {
+    std::cout << "Request for register new type\n"
+              << "name: " << typeid(T).name() << "\n"
+              << "uuid: " << to_string(*this) << "\n";
  }

-    explicit type_id(boost::uuids::uuid const& u)
-            : boost::uuids::uuid(u) {}
-
-    operator boost::uuids::uuid() {
-        return static_cast<boost::uuids::uuid&>(*this);
-    }
-
-    operator boost::uuids::uuid() const {
-        return static_cast<boost::uuids::uuid const&>(*this);
-    }
+  explicit type_id(boost::uuids::uuid const &u) : boost::uuids::uuid(u) {}

  unsigned int size() const { return m_size; }

@@ -83,9 +66,6 @@ private:
  unsigned int m_size;
 };

-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -95,69 +75,56 @@ namespace detail {

 class TypeRegister {
  typedef boost::uuids::name_generator IDGen_t;
+
 public:
  struct RegisterEntry {
    uuid_t id;
    int size;
  };

-    TypeRegister(uuid_t const &dns) :
-        gen(dns) {}
+  TypeRegister(uuid_t const &dns) : gen(dns) {}

-
-    template< typename T >
-    RegisterEntry * AddType(T *t = NULL) {
-        RegisterEntry en = { gen(typeid(T).name()), sizeof(T) };
-        for(int i=0; i < m_registry.size(); ++i)
-            if(en.id == m_registry[i].id) return &(m_registry[i]);
+  template <typename T> RegisterEntry *AddType(T *t = NULL) {
+    RegisterEntry en = {gen(typeid(T).name()), sizeof(T)};
+    for (int i = 0; i < m_registry.size(); ++i)
+      if (en.id == m_registry[i].id)
+        return &(m_registry[i]);
    m_registry.push_back(en);
    return &m_registry.back();
  }

  void PrintSelf(std::ostream &o) {
    std::cout << "RegisterController: \n";
-        for (int i=0; i<m_registry.size(); ++i)
-            o << "type [" << i << "]: "
-              << to_string(m_registry[i].id) << " "
+    for (int i = 0; i < m_registry.size(); ++i)
+      o << "type [" << i << "]: " << to_string(m_registry[i].id) << " "
        << m_registry[i].size << "\n";
    o << "\n";
  }

-
-
 private:
  IDGen_t gen;
-    Vector<RegisterEntry> m_registry;
-
+  std::vector<RegisterEntry> m_registry;
 };

-} // detail
-
-
-
+} // namespace detail

 class TypeRegister : public detail::TypeRegister {
 public:
  typedef detail::TypeRegister BaseClass;
  typedef detail::TypeRegister::RegisterEntry Entry;

-    static TypeRegister* Controller();
+  static TypeRegister *Controller();

 private:
  TypeRegister();                  // Blocks constructor
  static TypeRegister *s_Instance; // Singleton instance
 };

-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // OBJECT REGISTER //

-
-
-} // uLib
+} // namespace uLib

 #endif // UUID_H
--- a/src/Core/Vector.h
+++ b/src/Core/Vector.h
@@ -23,118 +23,405 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef U_CORE_VECTOR_H
 #define U_CORE_VECTOR_H

-#include <vector>
 #include <iostream>
+#include <map>
+#include <mutex>
+#include <vector>
+
+#include <Core/DataAllocator.h>

-#include <Core/StaticInterface.h>
-#include <Core/SmartPointer.h>
 #include <Core/CommaInitializer.h>
+#include <Core/SmartPointer.h>
+#include <Core/StaticInterface.h>

+#ifdef USE_CUDA
+#include <thrust/device_ptr.h>
+#include <thrust/device_vector.h>
+#endif

 namespace uLib {

+// MetaAllocator Implementation ...
+template <typename T> class MetaAllocator {
+public:
+  using value_type = T;
+  using pointer = T *;
+  using const_pointer = const T *;
+  using reference = T &;
+  using const_reference = const T &;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  template <class U> struct rebind {
+    using other = MetaAllocator<U>;
+  };
+
+  MetaAllocator() noexcept = default;
+
+  template <class U>
+  constexpr MetaAllocator(const MetaAllocator<U> &) noexcept {}
+
+  T *allocate(std::size_t n) {
+    if (n == 0)
+      return nullptr;
+
+    DataAllocator<T> *da = new DataAllocator<T>(n, false);
+    T *ptr = da->GetRAMData();
+
+    std::lock_guard<std::mutex> lock(GetMutex());
+    GetAllocationMap()[ptr] = da;
+    return ptr;
+  }
+
+  void deallocate(T *p, std::size_t /*n*/) noexcept {
+    if (!p)
+      return;
+
+    std::lock_guard<std::mutex> lock(GetMutex());
+    auto &map = GetAllocationMap();
+    auto it = map.find(p);
+    if (it != map.end()) {
+      delete it->second;
+      map.erase(it);
+    }
+  }
+
+  static DataAllocator<T> *GetDataAllocator(T *p) {
+    if (!p)
+      return nullptr;
+    std::lock_guard<std::mutex> lock(GetMutex());
+    auto &map = GetAllocationMap();
+    auto it = map.find(p);
+    if (it != map.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+private:
+  static std::map<T *, DataAllocator<T> *> &GetAllocationMap() {
+    static std::map<T *, DataAllocator<T> *> allocMap;
+    return allocMap;
+  }
+
+  static std::mutex &GetMutex() {
+    static std::mutex mtx;
+    return mtx;
+  }
+};
+
+template <class T, class U>
+bool operator==(const MetaAllocator<T> &, const MetaAllocator<U> &) {
+  return true;
+}
+template <class T, class U>
+bool operator!=(const MetaAllocator<T> &, const MetaAllocator<U> &) {
+  return false;
+}
+
 // Vector Implemetation ... wraps std::vector
-template <typename T>
-class Vector : public std::vector<T, std::allocator<T> >
-{    
-    typedef std::vector< T,std::allocator<T> > BaseClass;
-    typedef std::allocator<T> Allocator;
+template <typename T> class Vector : public std::vector<T, MetaAllocator<T>> {
+  typedef std::vector<T, MetaAllocator<T>> BaseClass;
+  typedef MetaAllocator<T> Allocator;
+
 public:
  typedef T TypeData;
-    typedef __gnu_cxx::__normal_iterator<T*, BaseClass >       Iterator;
-    typedef __gnu_cxx::__normal_iterator<const T*, BaseClass>  ConstIterator;
+  typedef __gnu_cxx::__normal_iterator<T *, BaseClass> Iterator;
+  typedef __gnu_cxx::__normal_iterator<const T *, BaseClass> ConstIterator;

-    typedef CommaInitializer< Vector<T> , T > VectorCommaInit;
+  typedef CommaInitializer<Vector<T>, T> VectorCommaInit;
+  typedef typename BaseClass::iterator iterator;
+  typedef typename BaseClass::const_iterator const_iterator;
+  typedef typename BaseClass::size_type size_type;
+  typedef typename BaseClass::reference reference;

  Vector(unsigned int size) : BaseClass(size) {}
-    Vector(unsigned int size, T &value) : BaseClass(size,value) {}
+  Vector(unsigned int size, T &value) : BaseClass(size, value) {}
  Vector() : BaseClass(0) {}
+  Vector(std::initializer_list<T> init) : BaseClass(init) {}

-    inline VectorCommaInit operator <<(T scalar) {
+  inline VectorCommaInit operator<<(T scalar) {
    return VectorCommaInit(this, scalar);
  }

+  void MoveToVRAM() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      alloc->MoveToVRAM();
+    }
+  }
+
+  void MoveToRAM() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      alloc->MoveToRAM();
+    }
+  }
+
+  T *GetVRAMData() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      return alloc->GetVRAMData();
+    }
+    return nullptr;
+  }
+
+  const T *GetVRAMData() const {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(
+            const_cast<T *>(BaseClass::data()))) {
+      return alloc->GetVRAMData();
+    }
+    return nullptr;
+  }
+
+#ifdef USE_CUDA
+  /// Returns a thrust::device_ptr to the VRAM data (valid after MoveToVRAM()).
+  /// thrust::device_ptr<T> is itself a random-access iterator compatible with
+  /// all thrust algorithms (thrust::transform, thrust::sort,
+  /// thrust::for_each…).
+  thrust::device_ptr<T> DeviceData() {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(BaseClass::data())) {
+      return thrust::device_pointer_cast(alloc->GetVRAMData());
+    }
+    return thrust::device_ptr<T>(nullptr);
+  }
+
+  thrust::device_ptr<const T> DeviceData() const {
+    if (auto alloc = MetaAllocator<T>::GetDataAllocator(
+            const_cast<T *>(BaseClass::data()))) {
+      return thrust::device_pointer_cast(
+          static_cast<const T *>(alloc->GetVRAMData()));
+    }
+    return thrust::device_ptr<const T>(nullptr);
+  }
+
+  /// Device-side begin iterator (valid after MoveToVRAM()).
+  thrust::device_ptr<T> DeviceBegin() { return DeviceData(); }
+
+  /// Device-side end iterator (valid after MoveToVRAM()).
+  thrust::device_ptr<T> DeviceEnd() {
+    return DeviceData() + static_cast<std::ptrdiff_t>(BaseClass::size());
+  }
+
+  thrust::device_ptr<const T> DeviceBegin() const { return DeviceData(); }
+
+  thrust::device_ptr<const T> DeviceEnd() const {
+    return DeviceData() + static_cast<std::ptrdiff_t>(BaseClass::size());
+  }
+#endif // USE_CUDA
+
  inline void PrintSelf(std::ostream &o);

+  // Overrides for auto-sync //
+  T &operator[](size_t i) {
+    this->MoveToRAM();
+    return BaseClass::operator[](i);
+  }
+  const T &operator[](size_t i) const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::operator[](i);
+  }
+  T &at(size_t i) {
+    this->MoveToRAM();
+    return BaseClass::at(i);
+  }
+  const T &at(size_t i) const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::at(i);
+  }
+  T &front() {
+    this->MoveToRAM();
+    return BaseClass::front();
+  }
+  const T &front() const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::front();
+  }
+  T &back() {
+    this->MoveToRAM();
+    return BaseClass::back();
+  }
+  const T &back() const {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::back();
+  }
+  T *data() noexcept {
+    this->MoveToRAM();
+    return BaseClass::data();
+  }
+  const T *data() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::data();
+  }
+  Iterator begin() noexcept {
+    this->MoveToRAM();
+    return BaseClass::begin();
+  }
+  ConstIterator begin() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::begin();
+  }
+  Iterator end() noexcept {
+    this->MoveToRAM();
+    return BaseClass::end();
+  }
+  ConstIterator end() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::end();
+  }
+  auto rbegin() noexcept {
+    this->MoveToRAM();
+    return BaseClass::rbegin();
+  }
+  auto rbegin() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::rbegin();
+  }
+  auto rend() noexcept {
+    this->MoveToRAM();
+    return BaseClass::rend();
+  }
+  auto rend() const noexcept {
+    const_cast<Vector *>(this)->MoveToRAM();
+    return BaseClass::rend();
+  }
+
+  void push_back(const T &x) {
+    this->MoveToRAM();
+    BaseClass::push_back(x);
+  }
+  void push_back(T &&x) {
+    this->MoveToRAM();
+    BaseClass::push_back(std::move(x));
+  }
+  template <typename... Args> reference emplace_back(Args &&...args) {
+    this->MoveToRAM();
+    return BaseClass::emplace_back(std::forward<Args>(args)...);
+  }
+  void pop_back() {
+    this->MoveToRAM();
+    BaseClass::pop_back();
+  }
+
+  template <typename... Args>
+  iterator emplace(const_iterator pos, Args &&...args) {
+    this->MoveToRAM();
+    return BaseClass::emplace(pos, std::forward<Args>(args)...);
+  }
+  iterator insert(const_iterator pos, const T &x) {
+    this->MoveToRAM();
+    return BaseClass::insert(pos, x);
+  }
+  iterator insert(const_iterator pos, T &&x) {
+    this->MoveToRAM();
+    return BaseClass::insert(pos, std::move(x));
+  }
+  template <typename InputIt>
+  iterator insert(const_iterator pos, InputIt first, InputIt last) {
+    this->MoveToRAM();
+    return BaseClass::insert(pos, first, last);
+  }
+  iterator erase(const_iterator pos) {
+    this->MoveToRAM();
+    return BaseClass::erase(pos);
+  }
+  iterator erase(const_iterator first, const_iterator last) {
+    this->MoveToRAM();
+    return BaseClass::erase(first, last);
+  }
+
+  void resize(size_t n) {
+    this->MoveToRAM();
+    BaseClass::resize(n);
+  }
+  void resize(size_t n, const T &x) {
+    this->MoveToRAM();
+    BaseClass::resize(n, x);
+  }
+  void reserve(size_t n) {
+    this->MoveToRAM();
+    BaseClass::reserve(n);
+  }
+  void clear() noexcept {
+    this->MoveToRAM();
+    BaseClass::clear();
+  }
+  template <typename InputIt> void assign(InputIt first, InputIt last) {
+    this->MoveToRAM();
+    BaseClass::assign(first, last);
+  }
+  void assign(size_type count, const T &value) {
+    this->MoveToRAM();
+    BaseClass::assign(count, value);
+  }
+
  void remove_element(unsigned int index) {
-        std::swap(this->at(index),this->back());
+    this->MoveToRAM();
+    std::swap(this->at(index), this->back());
    this->pop_back();
  }

  void remove_element(T &t) {
+    this->MoveToRAM();
    std::swap(t, this->back());
    this->pop_back();
  }
-
 };

-template<typename T>
-void Vector<T>::PrintSelf(std::ostream &o)
-{
+template <typename T> void Vector<T>::PrintSelf(std::ostream &o) {
  o << " *** uLib Vector *** \n";
  o << " n. of items = " << this->size() << "\n";
-    for(int i=0; i< this->size(); ++i)
+  for (int i = 0; i < this->size(); ++i)
    o << (T)this->at(i) << " ";
  o << "\n";
 }

 template <typename T>
-std::ostream & operator << (std::ostream &o, const Vector<T> &v) {
-    for(int i=0; i< v.size(); ++i)
+std::ostream &operator<<(std::ostream &o, const Vector<T> &v) {
+  for (int i = 0; i < v.size(); ++i)
    o << (T)v.at(i) << " ";
  o << "\n";
  return o;
 }

 template <typename T>
-std::ofstream & operator << (std::ofstream &o, const Vector<T> &v) {
-    for(int i=0; i< v.size(); ++i)
+std::ofstream &operator<<(std::ofstream &o, const Vector<T> &v) {
+  for (int i = 0; i < v.size(); ++i)
    o << (T)v.at(i) << " ";
  return o;
 }

-
-template < typename T >
-std::istream & operator >> (std::istream &is, Vector<T> &v) {
+template <typename T> std::istream &operator>>(std::istream &is, Vector<T> &v) {
  T value;
-    while( is >> value ) {
-        if(is.fail()) v.push_back(0);
-        else v.push_back( value );
+  while (is >> value) {
+    if (is.fail())
+      v.push_back(0);
+    else
+      v.push_back(value);
  }
  return is;
 }

-
-
 // Smart pointer Vector Implementation //

+template <typename T> class SmartVector : public SmartPointer<Vector<T>> {
+  typedef SmartPointer<Vector<T>> Base;

-template <typename T>
-class SmartVector : public SmartPointer< Vector<T> > {
-    typedef SmartPointer< Vector<T> > Base;
 public:
-
-  SmartVector() : Base(new Vector<T>()) { }
-  SmartVector( const SmartVector &copy) : Base(copy) { }
-  SmartVector(unsigned int size) : Base(new Vector<T>((int)size)) { }
+  SmartVector() : Base(new Vector<T>()) {}
+  SmartVector(const SmartVector &copy) : Base(copy) {}
+  SmartVector(unsigned int size) : Base(new Vector<T>((int)size)) {}

  virtual ~SmartVector() {}

-  T& operator[](int p) {
-      return Base::get()->at(p);
-  }
+  T &operator[](int p) { return Base::get()->at(p); }

  void swap_elements(unsigned int first, unsigned int second) {
-      std::swap(Base::get()->at(first),Base::get()->at(second));
+    std::swap(Base::get()->at(first), Base::get()->at(second));
  }

  void remove_element(unsigned int index) {
-      std::swap(Base::get()->at(index),Base::get()->back());
+    std::swap(Base::get()->at(index), Base::get()->back());
    Base::get()->pop_back();
  }

@@ -144,35 +431,25 @@ public:
  }
 };

-
-
-
 // ------ Utils ------------------------------------------------------------- //

-
-
 // RIFARE con iteratore !
 template <typename _Tp, class _CmpT>
-inline const unsigned long
-VectorSplice(const _Tp &_it, const _Tp &_end, const float value, _CmpT _comp)
-{
+inline unsigned long VectorSplice(const _Tp &_it, const _Tp &_end,
+                                  const float value, _CmpT _comp) {
  _Tp it = _it;
-    _Tp end = _end-1;
-    for(it; it != end;)
-    {
-        if (_comp(*it,value))       ++it;
-        else if(_comp(*end,value))  std::swap(*it,*end--);
-        else                        --end;
+  _Tp end = _end - 1;
+  for (; it != end;) {
+    if (_comp(*it, value))
+      ++it;
+    else if (_comp(*end, value))
+      std::swap(*it, *end--);
+    else
+      --end;
  }
  return it - _it;
 }

-
-
-} // uLib
-
-
-
-
+} // namespace uLib

 #endif // VECTOR_H
--- a/src/Core/testing/CMakeLists.txt
+++ b/src/Core/testing/CMakeLists.txt
@@ -8,7 +8,7 @@ set( TESTS
        ObjectCopyTest
        StaticInterfaceTest
        CommaInitTest
-        DebugTTreeDumpTest
+        # DebugTTreeDumpTest
        BoostTest
        BoostAccumulatorTest
        PropertiesTest
@@ -16,18 +16,23 @@ set( TESTS
        SerializeTest
        SerializeDreadDiamondTest
        DreadDiamondParameters
-        ObjectPropableTest
        UuidTest
        TypeIntrospectionTraversal
        OptionsTest
+        PingPongTest
+        VectorMetaAllocatorTest
 )

 set(LIBRARIES
       ${PACKAGE_LIBPREFIX}Core
       ${PACKAGE_LIBPREFIX}Math
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
+       Boost::serialization
+       Boost::program_options
       ${ROOT_LIBRARIES}
 )
-uLib_add_tests(${uLib-module})
+uLib_add_tests(Core)
+
+if(USE_CUDA)
+    set_source_files_properties(VectorMetaAllocatorTest.cpp PROPERTIES LANGUAGE CUDA)
+endif()
+
--- a/src/Core/testing/Makefile.am
+++ b/src/Core/testing/Makefile.am
@@ -19,7 +19,6 @@ TESTS = SmartPointerTest \
 	SerializeTest \
 	SerializeDreadDiamondTest \
 	DreadDiamondParameters \
-	ObjectPropableTest \
 	TypeIntrospectionTraversal \
        OptionsTest

--- a/src/Core/testing/ObjectPropableTest.cpp
+++ b/src/Core/testing/ObjectPropableTest.cpp
@@ -1,237 +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 <iostream>
-#include <fstream>
-#include <typeinfo>
-#include <string>
-
-
-#include "Core/Types.h"
-#include "Core/Object.h"
-#include "Core/ObjectProps.h"
-#include "Core/StringReader.h"
-#include "Math/Dense.h"
-
-#include "boost/archive/text_oarchive.hpp"
-#include "boost/archive/text_iarchive.hpp"
-
-
-#include "testing-prototype.h"
-
-
-
-
-using namespace uLib;
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// STRUCTURES //
-
-
-struct A : virtual Object {
-
-    uLibTypeMacro(A, Object)
-
-    properties() {
-        int      p_a;
-        Vector3f p_3f;
-    };
-
-    int m_a;
-};
-
-void A::init_properties() {
-    $_init();
-    $$.p_a   = 0;
-    $$.p_3f << 1,2,3;
-}
-
-ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A, Object) { ar & AR(m_a); }
-ULIB_SERIALIZE_OBJECT_PROPS(A)   { ar & AR(p_a) & AR(p_3f); }
-
-
-
-
-struct B : A {
-    uLibTypeMacro(B,A)
-
-    properties() {
-        std::string p;
-    };
-
-    B() : m_b(324) {}
-
-    int m_b;
-};
-
-
-void B::init_properties() {
-    $_init();
-    $$.p = "ciao";
-}
-
-ULIB_SERIALIZABLE_OBJECT(B)
-ULIB_SERIALIZE_OBJECT(B,A)     { ar & AR(m_b); }
-ULIB_SERIALIZE_OBJECT_PROPS(B) { ar & AR(p);   }
-
-
-
-struct C {
-    int m_c;    
-    std::string m_str;
-};
-
-ULIB_SERIALIZABLE(C)
-ULIB_SERIALIZE(C) { ar & AR(m_c) & AR(m_str); }
-
-
-
-struct D : virtual Object, B {
-    uLibTypeMacro(D,Object,B)
-
-    properties() {
-        C p_c;
-    };
-};
-
-void D::init_properties() {
-    $_init();
-    $$.p_c.m_c = 1234;
-}
-
-ULIB_SERIALIZABLE_OBJECT(D)
-ULIB_SERIALIZE_OBJECT(D,Object) {}
-ULIB_SERIALIZE_OBJECT_PROPS(D) {
- ar & AR(p_c);
-}
-
-
-
-class E : public C, public D {
-    uLibTypeMacro(E,D,C)
-public:
-        E() : m_Ea(5552368) {}
-        int m_Ea;
-};
-
-ULIB_SERIALIZABLE_OBJECT(E)
-ULIB_SERIALIZE_OBJECT(E,C,D) {
-    ar & AR(m_Ea);
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// TESTS //
-
-
-int test_xml_direct() {
-    // TEST ARCHIVE SAVE AND LOAD direct //
-    E o; o.init_properties();
-    o.$$.p_c.m_str = "works";
-    {
-        std::ofstream file("test.xml");
-        Archive::xml_oarchive ar(file);
-        ar << NVP(o);
-    }
-    o.$$.p_c.m_str = "hola";
-    {
-        std::ifstream file("test.xml");
-        Archive::xml_iarchive ar(file);
-        ar >> NVP(o);
-    }
-    std::cout << o.$$.p_c.m_str << "\n";
-    return ( o.$$.p_c.m_str == "works" );
-}
-
-
-int test_xml_pointer() {
-    // TEST ARCHIVE SAVE AND LOAD from pointer //
-    E *o = new E; o->init_properties();
-    o->$$.p_c.m_str = "works";
-    {
-        std::ofstream file("test.xml");
-        Archive::xml_oarchive ar(file);
-        ar << NVP(o);
-    }
-    o->$$.p_c.m_str = "hola";
-    {
-        std::ifstream file("test.xml");
-        Archive::xml_iarchive ar(file);
-        ar >> NVP(o);
-    }
-    std::cout << o->$$.p_c.m_str << "\n";
-    return ( o->$$.p_c.m_str == "works" );
-}
-
-
-int test_xml_objsave() {
-    // TEST SELF SAVE
-    E o; o.init_properties();
-    o.$(B).p = "works";
-    {
-        std::ofstream file("test.xml");
-        Object::SaveXml(file,o);
-    }
-    o.$(B).p = "hola";
-    {
-        std::ifstream file("test.xml");
-        Object::LoadXml(file,o);
-    }
-
-    std::cout << o.$(B).p << "\n";
-    return ( o.$(B).p == "works" );
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// MAIN //
-
-int main()
-{
-    BEGIN_TESTING(PropableTest);
-
-    TEST1( test_xml_direct()  );
-    TEST1( test_xml_pointer() );
-    TEST1( test_xml_objsave() );
-
-    END_TESTING;
-}
-
-
--- a/src/Core/testing/PingPongTest.cpp
+++ b/src/Core/testing/PingPongTest.cpp
@@ -0,0 +1,52 @@
+#include "Core/Object.h"
+#include "Core/Signal.h"
+#include "testing-prototype.h"
+#include <iostream>
+
+using namespace uLib;
+
+class Ping : public Object {
+public:
+signals:
+  void PingSignal(int count);
+public slots:
+  void OnPong(int count) {
+    std::cout << "Ping received Pong " << count << std::endl;
+    if (count > 0)
+      ULIB_SIGNAL_EMIT(Ping::PingSignal, count - 1);
+  }
+};
+
+void Ping::PingSignal(int count) { ULIB_SIGNAL_EMIT(Ping::PingSignal, count); }
+
+class Pong : public Object {
+public:
+signals:
+  void PongSignal(int count);
+public slots:
+  void OnPing(int count) {
+    std::cout << "Pong received Ping " << count << std::endl;
+    if (count > 0)
+      ULIB_SIGNAL_EMIT(Pong::PongSignal, count - 1);
+  }
+};
+
+void Pong::PongSignal(int count) { ULIB_SIGNAL_EMIT(Pong::PongSignal, count); }
+
+int main() {
+  BEGIN_TESTING(PingPong);
+  Ping ping;
+  Pong pong;
+
+  std::cout << "Connecting ping to pong" << std::endl;
+  Object::connect(&ping, &Ping::PingSignal, &pong, &Pong::OnPing);
+
+  std::cout << "Connecting pong to ping" << std::endl;
+  Object::connect(&pong, &Pong::PongSignal, &ping, &Ping::OnPong);
+
+  std::cout << "Emitting PingSignal(5)" << std::endl;
+  ping.PingSignal(5);
+
+  END_TESTING;
+  return 0;
+}
--- a/src/Core/testing/SerializeDreadDiamondTest.cpp
+++ b/src/Core/testing/SerializeDreadDiamondTest.cpp
@@ -23,13 +23,10 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
-
-#include <iostream>
 #include <fstream>
-#include <typeinfo>
+#include <iostream>
 #include <string>
+#include <typeinfo>

 #include "Core/Object.h"

@@ -37,78 +34,43 @@

 using namespace uLib;

-
-
-
-
-
-
 struct A : Object {
-    uLibTypeMacro(A,Object)
-    A() : numa(5552368) {}
+  uLibTypeMacro(A, Object) A() : numa(5552368) {}
  int numa;
 };

-
 ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A,Object) {
-   ar & AR(numa);
-}
+ULIB_SERIALIZE_OBJECT(A, Object) { ar &AR(numa); }

 struct B : virtual Object {
-    uLibTypeMacro(B,Object)
-    B() : numb(5552369) {}
+  uLibTypeMacro(B, Object) B() : numb(5552369) {}
  int numb;
 };

 ULIB_SERIALIZABLE_OBJECT(B)
-ULIB_SERIALIZE_OBJECT(B,Object) { ar & AR(numb); }
-
+ULIB_SERIALIZE_OBJECT(B, Object) { ar &AR(numb); }

 struct C : B {
-    uLibTypeMacro(C,B)
-    C() : numc(5552370) {}
+  uLibTypeMacro(C, B) C() : numc(5552370) {}
  int numc;
 };

 ULIB_SERIALIZABLE_OBJECT(C)
-ULIB_SERIALIZE_OBJECT(C,B) { ar & AR(numc); }
+ULIB_SERIALIZE_OBJECT(C, B) { ar &AR(numc); }

-struct D : A,B {
-    uLibTypeMacro(D,A,B)
+struct D : A, B {
+  uLibTypeMacro(D, A, B)

-    D() : numd(5552371) {}
+      D()
+      : numd(5552371) {}
  int numd;
 };

 ULIB_SERIALIZABLE_OBJECT(D)
-ULIB_SERIALIZE_OBJECT(D,A,B) { ar & AR(numd); }
+ULIB_SERIALIZE_OBJECT(D, A, B) { ar &AR(numd); }

-
-
-main() {
-    A o; o.init_properties();
+int main() {
+  A o;

  Archive::xml_oarchive(std::cout) << NVP(o);
-
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
--- a/src/Core/testing/SerializeTest.cpp
+++ b/src/Core/testing/SerializeTest.cpp
@@ -23,21 +23,16 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
-
-#include <iostream>
 #include <fstream>
+#include <iostream>

-#include "Core/Object.h"
 #include "Core/Archives.h"
-#include "ParticlePhysics/MuonTomography/MuonScatter.h"
+#include "Core/Object.h"

 #include "testing-prototype.h"

 using namespace uLib;

-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -46,49 +41,41 @@ using namespace uLib;

 struct V3f {

-    float x,y,z;
-    V3f()
-    { x = y = z =0; }
+  float x, y, z;
+  V3f() { x = y = z = 0; }

-    V3f(float x, float y, float z) :
-        x(x), y(y), z(z) {}
+  V3f(float x, float y, float z) : x(x), y(y), z(z) {}

-    template <class Archive>
-    void serialize (Archive &ar,unsigned int v) {
-        ar
-                & "<" & NVP(x) & NVP(y) & NVP(z) & ">";
+  template <class Archive> void serialize(Archive &ar, unsigned int v) {
+    ar & "<" & NVP(x) & NVP(y) & NVP(z) & ">";
  }
 };

 ULIB_CLASS_EXPORT_KEY(V3f);
 ULIB_CLASS_EXPORT_IMPLEMENT(V3f);

-
-inline std::ostream &
-operator <<(std::ostream &o, const V3f &v) {
+inline std::ostream &operator<<(std::ostream &o, const V3f &v) {
  Archive::hrt_oarchive(o) << v;
  return o;
 }

-inline std::istream &
-operator >>(std::istream &is, V3f &v) {
+inline std::istream &operator>>(std::istream &is, V3f &v) {
  Archive::hrt_iarchive(is) >> v;
  return is;
 }

-
-
-
 int test_V3f() {
  // testing human readble archive with simple serializable structure //

-    V3f v1(1,2,3),v2,v3,v4;
+  V3f v1(1, 2, 3), v2, v3, v4;
  std::cout << "v    --> " << v1 << "\n";

-    std::stringstream ss; ss << v1;
+  std::stringstream ss;
+  ss << v1;
  std::cout << "ss.v --> " << ss.str() << "\n";

-    Archive::hrt_iarchive ar(ss); ar >> v2;
+  Archive::hrt_iarchive ar(ss);
+  ar >> v2;
  std::cout << "v2   --> " << v2 << "\n";

  std::stringstream("<2 3 4>") >> v3;
@@ -99,10 +86,6 @@ int test_V3f() {
  return (1);
 }

-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -110,70 +93,56 @@ int test_V3f() {
 // OBJECT SERIALIZATION //

 class A : public virtual Object {
-    uLibTypeMacro(A,Object)
-    ULIB_SERIALIZE_ACCESS
-public:
-    A() : m_a(5552368) {}
+uLibTypeMacro(A, Object) ULIB_SERIALIZE_ACCESS public : A() : m_a(5552368) {}

-    properties() {
+  void init_properties();
  std::string p_a;
-    };

-    uLibRefMacro (a,int);
+  uLibRefMacro(a, int);
+
 private:
  int m_a;
 };

-void A::init_properties() {
-    $_init();
-    $$.p_a = "A property string";
-}
+void A::init_properties() { p_a = "A property string"; }

 ULIB_SERIALIZABLE_OBJECT(A)
-ULIB_SERIALIZE_OBJECT(A,Object) {
-    ar
-            & "Object A : "
-            & "--> m_a = " & AR(m_a)
-            & "\n";
+ULIB_SERIALIZE_OBJECT(A, Object) {
+  ar & "Object A : " & "--> m_a = " & AR(m_a) & "\n" & "Object A properties: " &
+      "---> p_a = " & AR(p_a) & "\n";
 }

-ULIB_SERIALIZE_OBJECT_PROPS(A) {
-    ar
-            & "Object A properties: "
-            & "---> p_a = " & AR(p_a) & "\n";
-}
-
-
-
 int testing_xml_class() {

-    A a; a.init_properties();
+  A a;
+  a.init_properties();

  {
    std::ofstream file("test.xml");
    Archive::xml_oarchive(file) << NVP(a);
  }
  a.a() = 0;
-    a.$$.p_a = "zero string";
+  a.p_a = "zero string";
  {
    std::ifstream file("test.xml");
    Archive::xml_iarchive(file) >> NVP(a);
  }

  Archive::xml_oarchive(std::cout) << NVP(a);
-    return ( a.a() == 5552368 && a.$$.p_a == "A property string" );
+  return (a.a() == 5552368 && a.p_a == "A property string");
 }

 int testing_hrt_class() {

-    A a; a.init_properties();
+  A a;
+  a.init_properties();

  {
    std::ofstream file("test.xml");
    Archive::hrt_oarchive(file) << NVP(a);
  }
  a.a() = 0;
-    a.$$.p_a = "zero string";
+  a.p_a = "zero string";
  {
    // ERRORE FIX !
    //        std::ifstream file("test.xml");
@@ -181,69 +150,15 @@ int testing_hrt_class() {
  }

  Archive::hrt_oarchive(std::cout) << NVP(a);
-    return ( a.a() == 5552368 && a.$$.p_a == "A property string" );
+  return (a.a() == 5552368 && a.p_a == "A property string");
 }

-
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// 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() );
+  TEST1(test_V3f());
+  TEST1(testing_xml_class());
  //    testing_hrt_class(); ///// << ERRORE in HRT with properties
-    TEST1( testing_mu() );

  END_TESTING;
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
--- a/src/Core/testing/SignalTest.cpp
+++ b/src/Core/testing/SignalTest.cpp
@@ -23,73 +23,45 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #include <iostream>
 #include <typeinfo>

-
-#include "testing-prototype.h"
-#include "Core/Types.h"
 #include "Core/Object.h"
 #include "Core/Signal.h"
-
+#include "Core/Types.h"
+#include "testing-prototype.h"

 using namespace uLib;

-
-
-
 class Ob1 : public Object {
 public:
-
-
 signals:
  void V0();

-    int V1(int a);
-
+  void V1(int a);
 };

-
-
-
 // should be done by moc //
-void Ob1::V0() {
-    ULIB_SIGNAL_EMIT(Ob1::V0);
-}
-
-int Ob1::V1(int a) {
-    ULIB_SIGNAL_EMIT(Ob1::V1,a);
-}
-
-
-
+void Ob1::V0() { ULIB_SIGNAL_EMIT(Ob1::V0); }

+void Ob1::V1(int a) { ULIB_SIGNAL_EMIT(Ob1::V1, a); }

 class Ob2 : public Object {

 public slots:
-    void PrintV0() {
-        std::cout << "Ob2 prints V0\n" << std::flush;
-    }
+  void PrintV0() { std::cout << "Ob2 prints V0\n" << std::flush; }
 };

 class Ob3 : public Object {

 public slots:
-    void PrintV0() {
-        std::cout << "Ob3 prints V0\n" << std::flush;
-    }
+  void PrintV0() { std::cout << "Ob3 prints V0\n" << std::flush; }

  void PrintNumber(int n) {
    std::cout << "Ob3 is printing number: " << n << "\n";
  }
 };

-
-
-
 int main() {
  BEGIN_TESTING(Signals);

@@ -97,9 +69,9 @@ int main() {
  Ob2 ob2;
  Ob3 ob3;

-    Object::connect(&ob1,&Ob1::V0,&ob2,&Ob2::PrintV0);
-    Object::connect(&ob1,&Ob1::V0,&ob3,&Ob3::PrintV0);
-    Object::connect(&ob1,&Ob1::V1,&ob3,&Ob3::PrintNumber);
+  Object::connect(&ob1, &Ob1::V0, &ob2, &Ob2::PrintV0);
+  Object::connect(&ob1, &Ob1::V0, &ob3, &Ob3::PrintV0);
+  Object::connect(&ob1, &Ob1::V1, &ob3, &Ob3::PrintNumber);

  //  not working yet
  //    Object::connect(&ob1,SIGNAL(V0(),&ob2,SLOT(PrintV0())
@@ -111,5 +83,3 @@ int main() {

  END_TESTING;
 }
-
-
--- a/src/Core/testing/StaticInterfaceTest.cpp
+++ b/src/Core/testing/StaticInterfaceTest.cpp
@@ -23,16 +23,11 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
-
 #include <iostream>

 #include "testing-prototype.h"
 #include <Core/StaticInterface.h>

-
-
 namespace uLib {

 //// INTERFACE TO COMPLEX CLASS /////
@@ -40,73 +35,61 @@ namespace uLib {
 namespace Interface {
 struct Test {
  MAKE_TRAITS
-    template<class Self> void check_structural() {
-        uLibCheckFunction(Self,test,bool,int,float);
-        uLibCheckMember(Self,testmemb,int);
+  template <class Self> void check_structural() {
+    uLibCheckFunction(Self, test, bool, int, float);
+    uLibCheckMember(Self, testmemb, int);
  }
 };
-}
+} // namespace Interface

 struct Test {
-    bool test(int i, float f){}
+  bool test(int i, float f) { return true; }
  int testmemb;
 };

-
-
 //// INTERFAC TO SIMPLE CLASS ///////////

 namespace Interface {
 struct Simple {
  MAKE_TRAITS
-    template<class Self> void check_structural() {
-        uLibCheckMember(Self,memb1,int);
-        uLibCheckMember(Self,memb2,float);
+  template <class Self> void check_structural() {
+    uLibCheckMember(Self, memb1, int);
+    uLibCheckMember(Self, memb2, float);
  }
 };
-}
+} // namespace Interface

 struct Simple {
  int memb1;
  float memb2;
 };

-
 /////////////////////////

-template <class T>
-class UseTest {
+template <class T> class UseTest {
 public:
  UseTest() {
-        Interface::IsA<T,Interface::Test>();
+    Interface::IsA<T, Interface::Test>();
    T t;
-        int i; float f;
-        t.test(i,f);
+    int i;
+    float f;
+    t.test(i, f);
  }
 };

-template <class T>
-class UseSimple {
+template <class T> class UseSimple {
 public:
-    UseSimple() {
-        Interface::IsA<T,Interface::Simple>();
-    }
+  UseSimple() { Interface::IsA<T, Interface::Simple>(); }
 };

+} // namespace uLib

-
-}
-
-int main()
-{
+int main() {
  BEGIN_TESTING(Static Interface);

-
-
  uLib::UseTest<uLib::Test> u;

  uLib::UseSimple<uLib::Simple> s;

  END_TESTING;
 }
-
--- a/src/Core/testing/VectorMetaAllocatorTest.cpp
+++ b/src/Core/testing/VectorMetaAllocatorTest.cpp
@@ -0,0 +1,97 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// 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 >
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#include "testing-prototype.h"
+#include <Core/Vector.h>
+
+#ifdef USE_CUDA
+#include <thrust/device_ptr.h>
+#include <thrust/transform.h>
+
+struct DoubleFunctor {
+  __host__ __device__ int operator()(int x) const { return x * 2; }
+};
+#endif
+
+int main() {
+  BEGIN_TESTING(VectorMetaAllocator);
+
+  uLib::Vector<int> v;
+  std::cout << "Pushing elements...\n";
+  v << 1, 2, 3, 4, 5;
+
+  std::cout << "Initial RAM contents: ";
+  for (size_t i = 0; i < v.size(); ++i) {
+    std::cout << v[i] << " ";
+    if (v[i] != (int)(i + 1)) {
+      std::cout << "\nError: Value mismatch at index " << i << "\n";
+      exit(1);
+    }
+  }
+  std::cout << "\n";
+
+#ifdef USE_CUDA
+  std::cout << "Moving to VRAM...\n";
+  v.MoveToVRAM();
+
+  int *vram_ptr = v.GetVRAMData();
+  if (vram_ptr) {
+    std::cout << "Successfully obtained VRAM pointer: " << vram_ptr << "\n";
+  } else {
+    std::cout << "Error: Failed to obtain VRAM pointer!\n";
+    exit(1);
+  }
+
+  // Verify DeviceData() matches GetVRAMData()
+  {
+    thrust::device_ptr<int> dev_ptr = v.DeviceData();
+    if (dev_ptr.get() != vram_ptr) {
+      std::cout << "Error: DeviceData() does not match GetVRAMData()!\n";
+      exit(1);
+    }
+    std::cout << "DeviceData() matches GetVRAMData(). OK\n";
+  }
+
+  // Use thrust::transform via DeviceBegin()/DeviceEnd() to double all elements
+  // on device
+  std::cout << "Doubling elements on device via thrust::transform...\n";
+  thrust::transform(v.DeviceBegin(), v.DeviceEnd(), v.DeviceBegin(),
+                    DoubleFunctor{});
+
+  std::cout << "Moving back to RAM...\n";
+  v.MoveToRAM();
+
+  std::cout << "RAM contents after VRAM trip + thrust transform: ";
+  for (size_t i = 0; i < v.size(); ++i) {
+    std::cout << v[i] << " ";
+    if (v[i] != (int)((i + 1) * 2)) {
+      std::cout << "\nError: Data corrupted after RAM->VRAM->thrust->RAM trip "
+                   "at index "
+                << i << "\n";
+      exit(1);
+    }
+  }
+  std::cout << "\n";
+#else
+  std::cout << "USE_CUDA not defined, skipping VRAM tests.\n";
+#endif
+
+  std::cout << "Scaling vector...\n";
+  for (size_t i = 0; i < v.size(); ++i)
+    v[i] *= 10;
+
+  std::cout << "Final contents: ";
+  for (size_t i = 0; i < v.size(); ++i)
+    std::cout << v[i] << " ";
+  std::cout << "\n";
+
+  END_TESTING;
+}
--- a/src/Core/testing/VectorTest.cpp
+++ b/src/Core/testing/VectorTest.cpp
@@ -23,62 +23,47 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
-#include <Core/Vector.h>
 #include "testing-prototype.h"
+#include <Core/Vector.h>

 #include <algorithm>

-template < typename T >
-struct __Cmp {
-    bool operator()(const T &data, const float value) {
-        return data <= value;
-    }
+template <typename T> struct __Cmp {
+  bool operator()(const T &data, const float value) { return data <= value; }
 };

-
-
-
-template<typename _Tp, typename _CmpT>
-inline const unsigned long
-VectorSplice(const _Tp &_it, const _Tp &_end, const float value, _CmpT _comp)
-  {
+template <typename _Tp, typename _CmpT>
+inline const unsigned long VectorSplice(const _Tp &_it, const _Tp &_end,
+                                        const float value, _CmpT _comp) {

  _Tp it = _it;
-    _Tp end = _end-1;
-    for(it; it != end; )
-    {
-        if ( _comp(*it, value) ) it++;
-        else if( _comp(*end, value) )
-        {
-            std::swap(*it,*end--);
-        }
-        else --end;
+  _Tp end = _end - 1;
+  for (it; it != end;) {
+    if (_comp(*it, value))
+      it++;
+    else if (_comp(*end, value)) {
+      std::swap(*it, *end--);
+    } else
+      --end;
  }
  return it - _it;
 }

-
-int main()
-{
+int main() {
  BEGIN_TESTING(Vector);

  uLib::Vector<float> v;
-    v << 5,4,3,2,6,1,2,3,65,7,32,23,4,3,45,4,34,3,4,4,3,3,4,2,2,3;
+  v << 5, 4, 3, 2, 6, 1, 2, 3, 65, 7, 32, 23, 4, 3, 45, 4, 34, 3, 4, 4, 3, 3, 4,
+      2, 2, 3;

-
-
-    int id = VectorSplice(v.begin(),v.end(),3,__Cmp<float>());
+  int id = ::VectorSplice(v.begin(), v.end(), 3, __Cmp<float>());

  std::cout << "id: " << id << "\n";
  std::cout << "vector: ";
-    for(uLib::Vector<float>::Iterator it = v.begin(); it!=v.end(); it++)
-        std::cout << *it <<" ";
+  for (uLib::Vector<float>::Iterator it = v.begin(); it != v.end(); it++)
+    std::cout << *it << " ";
  std::cout << std::endl;
-//    std::sort(v.begin(),v.end(),LT<float>());
-
+  //    std::sort(v.begin(),v.end(),LT<float>());

  END_TESTING;
 }
-
--- a/src/Detectors/CMakeLists.txt
+++ b/src/Detectors/CMakeLists.txt
@@ -1,38 +1,12 @@
-# HEADERS
-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(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
+
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)


-# SOURCES
-set(SOURCES
-                Solid.cpp
-                Scene.cpp
-)
+install(FILES ${HEADERS}
+        DESTINATION ${INSTALL_INC_DIR}/Detectors)

-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)
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()
--- a/src/Detectors/HitMC.h
+++ b/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)
-    uLibGetMacro(Type, enum Type)
+    inline const HPoint3f & Position() const { return this->m_Position; }
+    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)
-    uLibSetMacro(Type, enum Type)
+    inline HPoint3f & Position() { return this->m_Position; }
+    inline void SetType(enum Type name) { this->m_Type = name; }
 };


--- a/src/Detectors/LinearFit.h
+++ b/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,15 +36,14 @@ namespace uLib {

 class LinearFitData {
 public:
-    uLibConstRefMacro(Position,Vector2f)
-    uLibConstRefMacro(Slope,Vector2f)
-    uLibConstRefMacro(PositionError,Vector2f)
-    uLibConstRefMacro(SlopeError,Vector2f)
-    uLibGetMacro(HitsNumber,int)
-    uLibGetMacro(Idv,ChamberDetector::ID)
+    inline const Vector2f & Position() const { return this->m_Position; }
+    inline const Vector2f & Slope() const { return this->m_Slope; }
+    inline const Vector2f & PositionError() const { return this->m_PositionError; }
+    inline const Vector2f & SlopeError() const { return this->m_SlopeError; }
+    inline int GetHitsNumber() const { return this->m_HitsNumber; }
+    inline ChamberDetector::ID GetIdv() const { return this->m_Idv; }

-private:
-        friend class LinearFit;
+protected:
    Vector2f            m_Position;
    Vector2f            m_Slope;
    Vector2f            m_PositionError;
@@ -57,12 +55,12 @@ private:

 class LinearFit : public LinearFitData {
 public:
-    uLibRefMacro(Position,Vector2f)
-    uLibRefMacro(Slope,Vector2f)
-    uLibRefMacro(PositionError,Vector2f)
-    uLibRefMacro(SlopeError,Vector2f)
-    uLibSetMacro(HitsNumber,int)
-    uLibSetMacro(Idv,ChamberDetector::ID)
+    inline Vector2f & Position() { return this->m_Position; }
+    inline Vector2f & Slope() { return this->m_Slope; }
+    inline Vector2f & PositionError() { return this->m_PositionError; }
+    inline Vector2f & SlopeError() { return this->m_SlopeError; }
+    inline void SetHitsNumber(int name) { this->m_HitsNumber = name; }
+    inline void SetIdv(ChamberDetector::ID name) { this->m_Idv = name; }
 };


--- a/src/Detectors/MuonError.h
+++ b/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)
-    uLibConstRefMacro(Phi,Scalarf)
-private:
+    inline const Scalarf & Theta() const { return this->m_Theta; }
+    inline const Scalarf & Phi() const { return this->m_Phi; }
+protected:
    Scalarf m_Theta;
    Scalarf m_Phi;
 };
@@ -47,8 +45,8 @@ private:

 class MuonError  : public MuonErrorData {
 public:
-    uLibRefMacro(Theta,Scalarf)
-    uLibRefMacro(Phi,Scalarf)
+    inline Scalarf & Theta() { return this->m_Theta; }
+    inline Scalarf & Phi() { return this->m_Phi; }
 };


--- a/src/Detectors/MuonEvent.h
+++ b/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)
-    uLibConstRefMacro(LineOut,HLine3f)
-    uLibGetMacro(Momentum,Scalarf)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
+    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)
-    uLibRefMacro(LineOut,HLine3f)
-    uLibRefMacro(Momentum,Scalarf)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
+    inline HLine3f & LineOut() { return this->m_LineOut; }
+    inline Scalarf & Momentum() { return this->m_Momentum; }

 };

--- a/src/Detectors/MuonScatter.h
+++ b/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)
-    uLibConstRefMacro(ErrorIn,HError3f)
-    uLibConstRefMacro(LineOut,HLine3f)
-    uLibConstRefMacro(ErrorOut,HError3f)
+    inline const HLine3f & LineIn() const { return this->m_LineIn; }
+    inline const HError3f & ErrorIn() const { return this->m_ErrorIn; }
+    inline const HLine3f & LineOut() const { return this->m_LineOut; }
+    inline const HError3f & ErrorOut() const { return this->m_ErrorOut; }

-    uLibRefMacro(LineIn,HLine3f)
-    uLibRefMacro(ErrorIn,HError3f)
-    uLibRefMacro(LineOut,HLine3f)
-    uLibRefMacro(ErrorOut,HError3f)
-    uLibSetMacro(Momentum,Scalarf)
-    uLibSetMacro(MomentumPrime,Scalarf)
+    inline HLine3f & LineIn() { return this->m_LineIn; }
+    inline HError3f & ErrorIn() { return this->m_ErrorIn; }
+    inline HLine3f & LineOut() { return this->m_LineOut; }
+    inline HError3f & ErrorOut() { return this->m_ErrorOut; }

-    uLibGetMacro(Momentum,Scalarf)
-    uLibGetMacro(MomentumPrime,Scalarf)
+    inline void SetMomentum(Scalarf name) { this->m_Momentum = name; }
+    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;
--- a/src/Detectors/testing/CMakeLists.txt
+++ b/src/Detectors/testing/CMakeLists.txt
@@ -1,18 +1,15 @@
 # TESTS
 set( TESTS
-            GDMLSolidTest
+#            GDMLSolidTest
            HierarchicalEncodingTest
 )

-#set(LIBRARIES
-#       ${PACKAGE_LIBPREFIX}Core
-#       ${PACKAGE_LIBPREFIX}Math
-#       ${PACKAGE_LIBPREFIX}Detectors
-#       ${Boost_SERIALIZATION_LIBRARY}
-#       ${Boost_SIGNALS_LIBRARY}
-#       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-#       ${Eigen_LIBRARY}
-#       ${Geant4_LIBRARIES}
-#       ${ROOT_LIBRARIES}
-#)
-uLib_add_tests(${uLib-module})
+set(LIBRARIES
+       ${PACKAGE_LIBPREFIX}Core
+       ${PACKAGE_LIBPREFIX}Math
+       Boost::serialization
+       Boost::program_options
+       Eigen3::Eigen
+       ${ROOT_LIBRARIES}
+)
+uLib_add_tests(Detectors)
--- a/src/Gui/Qt/QVTKViewport2/Makefile.am
+++ b/src/Gui/Qt/QVTKViewport2/Makefile.am
@@ -1,35 +0,0 @@
-# SUBDIRS = .
-
-include $(top_srcdir)/Common.am
-
-DISTSOURCES        = vtkviewport.cpp main.cpp
-DISTHEADERS_MOC    =
-DISTHEADERS_NO_MOC = 
-FORMS              = vtkviewport.ui 
-
-FORMHEADERS = $(FORMS:.ui=.h)
-MOC_CC = $(FORMS:.ui=.moc.cpp) $(DISTHEADERS_MOC:.h=.moc.cpp)
-
-bin_PROGRAMS    = QTVtkViewport
-
-BUILT_SOURCES = $(FORMHEADERS) $(MOC_CC)
-CLEANFILES    = $(BUILT_SOURCES)
-
-EXTRA_DIST                   = $(FORMS)
-QTVtkViewport_SOURCES        = $(DISTSOURCES) $(DISTHEADERS_MOC) $(DISTHEADERS_NO_MOC)
-nodist_QTVtkViewport_SOURCES = $(MOC_CC)
-
-QTVtkViewport_LDADD = $(top_srcdir)/libmutom.la
-
-
-.ui.h: $(FORMS)
-	$(UIC) -o ui_$@ $<
-
-.ui.hpp: $(FORMS_HPP)
-	$(UIC) -o $@ $<
-
-.h.moc.cpp:
-	$(MOC) -o $@ $<
-
-
-SUFFIXES = .h .ui .moc.cpp
--- a/src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro
+++ b/src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro
@@ -1,18 +0,0 @@
-#-------------------------------------------------
-#
-# Project created by QtCreator 2012-08-30T18:59:53
-#
-#-------------------------------------------------
-
-QT       += core gui
-
-TARGET = QVTKViewport2
-TEMPLATE = app
-
-
-SOURCES += main.cpp\
-        vtkviewport.cpp
-
-HEADERS  += vtkviewport.h
-
-FORMS    += vtkviewport.ui
--- a/src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro.user
+++ b/src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro.user
@@ -1,453 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE QtCreatorProject>
-<!-- Written by Qt Creator 2.4.1, 2012-09-03T09:43:56. -->
-<qtcreator>
- <data>
-  <variable>ProjectExplorer.Project.ActiveTarget</variable>
-  <value type="int">0</value>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.EditorSettings</variable>
-  <valuemap type="QVariantMap">
-   <value type="bool" key="EditorConfiguration.AutoIndent">true</value>
-   <value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
-   <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
-    <value type="QString" key="language">Cpp</value>
-    <valuemap type="QVariantMap" key="value">
-     <value type="QString" key="CurrentPreferences">CppGlobal</value>
-    </valuemap>
-   </valuemap>
-   <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
-    <value type="QString" key="language">QmlJS</value>
-    <valuemap type="QVariantMap" key="value">
-     <value type="QString" key="CurrentPreferences">QmlJSGlobal</value>
-    </valuemap>
-   </valuemap>
-   <value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
-   <value type="QByteArray" key="EditorConfiguration.Codec">System</value>
-   <value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
-   <value type="int" key="EditorConfiguration.IndentSize">4</value>
-   <value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
-   <value type="int" key="EditorConfiguration.PaddingMode">1</value>
-   <value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
-   <value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
-   <value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
-   <value type="int" key="EditorConfiguration.TabKeyBehavior">1</value>
-   <value type="int" key="EditorConfiguration.TabSize">8</value>
-   <value type="bool" key="EditorConfiguration.UseGlobal">true</value>
-   <value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
-   <value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
-   <value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
-   <value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
-   <value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
-  </valuemap>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.PluginSettings</variable>
-  <valuemap type="QVariantMap"/>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.Target.0</variable>
-  <valuemap type="QVariantMap">
-   <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
-   <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
-   <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Target.DesktopTarget</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 4.7.4 for GCC (Qt SDK) Release</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">3</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 4.7.4 for GCC (Qt SDK) Debug</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">3</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 in PATH (System) Release</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">4</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.3">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 in PATH (System) Debug</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">4</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.4">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 (System) Release</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">5</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.5">
-    <value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
-      <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
-      <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
-     </valuemap>
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
-    </valuemap>
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
-     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
-      <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
-      <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
-     </valuemap>
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
-    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
-    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 (System) Debug</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
-    <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">5</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
-   </valuemap>
-   <value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">6</value>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
-    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
-     <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Deploy</value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
-    </valuemap>
-    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">No deployment</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
-   </valuemap>
-   <value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
-   <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
-    <value type="bool" key="Analyzer.Project.UseGlobal">true</value>
-    <value type="bool" key="Analyzer.Project.UseGlobal">true</value>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
-    <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
-    <value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
-    <value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">false</value>
-    <value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">false</value>
-    <value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
-    <value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
-    <value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
-    <value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
-    <value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
-    <value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
-     <value type="int">2</value>
-     <value type="int">3</value>
-     <value type="int">4</value>
-     <value type="int">5</value>
-     <value type="int">6</value>
-     <value type="int">7</value>
-     <value type="int">8</value>
-     <value type="int">9</value>
-     <value type="int">10</value>
-    </valuelist>
-    <valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
-     <value type="int">2</value>
-     <value type="int">3</value>
-     <value type="int">4</value>
-     <value type="int">5</value>
-     <value type="int">6</value>
-     <value type="int">7</value>
-     <value type="int">8</value>
-     <value type="int">9</value>
-     <value type="int">10</value>
-    </valuelist>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">QVTKViewport2</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4RunConfiguration</value>
-    <value type="int" key="Qt4ProjectManager.Qt4RunConfiguration.BaseEnvironmentBase">2</value>
-    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.CommandLineArguments"></value>
-    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.ProFile">QVTKViewport2.pro</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix">false</value>
-    <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseTerminal">false</value>
-    <valuelist type="QVariantList" key="Qt4ProjectManager.Qt4RunConfiguration.UserEnvironmentChanges"/>
-    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value>
-    <value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
-    <value type="bool" key="RunConfiguration.UseCppDebugger">true</value>
-    <value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
-    <value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">false</value>
-   </valuemap>
-   <value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
-  </valuemap>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.TargetCount</variable>
-  <value type="int">1</value>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.Updater.EnvironmentId</variable>
-  <value type="QString">{f8bb0047-7f6e-45df-9cc8-e746abebf883}</value>
- </data>
- <data>
-  <variable>ProjectExplorer.Project.Updater.FileVersion</variable>
-  <value type="int">10</value>
- </data>
-</qtcreator>
--- a/src/Gui/Qt/QVTKViewport2/main.cpp
+++ b/src/Gui/Qt/QVTKViewport2/main.cpp
@@ -1,38 +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 <QtGui/QApplication>
-#include "vtkviewport.h"
-
-int main(int argc, char *argv[])
-{
-    QApplication a(argc, argv);
-    VtkViewport w;
-    w.show();
-    
-    return a.exec();
-}
--- a/src/Gui/Qt/QVTKViewport2/vtkviewport.cpp
+++ b/src/Gui/Qt/QVTKViewport2/vtkviewport.cpp
@@ -1,41 +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 "vtkviewport.h"
-#include "ui_vtkviewport.h"
-
-VtkViewport::VtkViewport(QWidget *parent) :
-    QWidget(parent),
-    ui(new Ui::VtkViewport)
-{
-    ui->setupUi(this);
-}
-
-VtkViewport::~VtkViewport()
-{
-    delete ui;
-}
--- a/src/Gui/Qt/QVTKViewport2/vtkviewport.h
+++ b/src/Gui/Qt/QVTKViewport2/vtkviewport.h
@@ -1,49 +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.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-#ifndef VTKVIEWPORT_H
-#define VTKVIEWPORT_H
-
-#include <QWidget>
-
-namespace Ui {
-class VtkViewport;
-}
-
-class VtkViewport : public QWidget
-{
-    Q_OBJECT
-    
-public:
-    explicit VtkViewport(QWidget *parent = 0);
-    ~VtkViewport();
-    
-private:
-    Ui::VtkViewport *ui;
-};
-
-#endif // VTKVIEWPORT_H
--- a/src/Gui/Qt/QVTKViewport2/vtkviewport.ui
+++ b/src/Gui/Qt/QVTKViewport2/vtkviewport.ui
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>VtkViewport</class>
- <widget class="QWidget" name="VtkViewport">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>580</width>
-    <height>536</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <widget class="QLabel" name="label">
-   <property name="geometry">
-    <rect>
-     <x>140</x>
-     <y>170</y>
-     <width>161</width>
-     <height>41</height>
-    </rect>
-   </property>
-   <property name="text">
-    <string>Hello World !</string>
-   </property>
-  </widget>
- </widget>
- <resources/>
- <connections/>
-</ui>
--- a/src/Math/Accumulator.h
+++ b/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;
 };


--- a/src/Math/BitCode.h
+++ b/src/Math/BitCode.h
@@ -27,15 +27,16 @@
 #ifndef U_MATH_BITCODE_H
 #define U_MATH_BITCODE_H

+#include <iostream>
+
 #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 +238,9 @@ public:
 //        std::cout << boost::mpl::at_c< BitSet,1 >::type::value << "\n";
    }

-    int Get(unsigned short field) const {
-        return boost::mpl::at_c< BitSet, field >::type::value;
-    }
+//    int Get(unsigned short field) const {
+//        return boost::mpl::at_c< BitSet, field >::type::value;
+//    }
 };


--- a/src/Math/CMakeLists.txt
+++ b/src/Math/CMakeLists.txt
@@ -1,7 +1,5 @@

-# HEADERS
-set(HEADERS
-                                ContainerBox.h
+set(HEADERS ContainerBox.h
            Dense.h
            Geometry.h
            Transform.h
@@ -22,29 +20,48 @@ set(HEADERS
            Accumulator.h
            TriangleMesh.h
            BitCode.h
-)
+            Structured2DGrid.h
+            Structured4DGrid.h)

-
-# SOURCES
-set(SOURCES
-                VoxRaytracer.cpp
+set(SOURCES VoxRaytracer.cpp
            StructuredData.cpp
            StructuredGrid.cpp
            VoxImage.cpp
            TriangleMesh.cpp
            Dense.cpp
-)
+            Structured2DGrid.cpp
+            Structured4DGrid.cpp)

-set(LIBRARIES
-       ${Boost_SERIALIZATION_LIBRARY}
-       ${Boost_SIGNALS_LIBRARY}
-       ${Boost_PROGRAM_OPTIONS_LIBRARY}
-       ${Eigen_LIBRARY}
+set(LIBRARIES Eigen3::Eigen
              ${ROOT_LIBRARIES}
-       ${PACKAGE_LIBPREFIX}Core
-       ${PACKAGE_LIBPREFIX}Math
-)
+              ${VTK_LIBRARIES})
+
+set(libname ${PACKAGE_LIBPREFIX}Math)
+set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
+set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Math PARENT_SCOPE)
+
+add_library(${libname} SHARED ${SOURCES})
+set_target_properties(${libname} PROPERTIES
+                      VERSION ${PROJECT_VERSION}
+                      SOVERSION ${PROJECT_SOVERSION}
+                      CXX_STANDARD 17
+                      CUDA_STANDARD 17)
+target_link_libraries(${libname} ${LIBRARIES})
+
+if(USE_CUDA)
+    set_source_files_properties(VoxRaytracer.cpp VoxImage.cpp PROPERTIES LANGUAGE CUDA)
+endif()


-uLib_add_shared_library(${uLib-module})
-add_subdirectory(testing)
+install(TARGETS ${libname}
+        EXPORT "${PROJECT_NAME}Targets"
+        RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
+        LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
+
+install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Math)
+
+if(BUILD_TESTING)
+  include(uLibTargetMacros)
+  add_subdirectory(testing)
+endif()
+
--- a/src/Math/Dense.cpp
+++ b/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

--- a/src/Math/Dense.h
+++ b/src/Math/Dense.h
@@ -23,9 +23,6 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
-
 /*
 * <one line to give the program's name and a brief idea of what it does.>
 * Copyright (C) 2012  Andrea Rigoni Garola <andrea@pcimg05>
@@ -47,17 +44,13 @@
 *
 */

-
 #ifndef ULIB_DENSEMATRIX_H
 #define ULIB_DENSEMATRIX_H

+// #include <Eigen/src/Core/Matrix.h>
 #include <stdlib.h>

 #include <Eigen/Dense>
-#include "Core/Types.h"
-#include "Core/Serializable.h"
-
-

 //// BOOST SERIALIZATION ///////////////////////////////////////////////////////

@@ -65,20 +58,23 @@
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/lexical_cast.hpp>
-#include <boost/serialization/string.hpp>
 #include <boost/serialization/array.hpp>
-
+#include <boost/serialization/string.hpp>

 namespace boost {
 namespace serialization {

-template<class Archive, class Scalar, int RowsAtCompileTime, int ColsAtCompileTime>
-void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> & m, const unsigned int /*version*/) {
-    ar & boost::serialization::make_array(m.data(), RowsAtCompileTime * ColsAtCompileTime);
+template <class Archive, class Scalar, int RowsAtCompileTime,
+          int ColsAtCompileTime>
+void serialize(Archive &ar,
+               ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> &m,
+               const unsigned int /*version*/) {
+  ar &boost::serialization::make_array(m.data(),
+                                       RowsAtCompileTime * ColsAtCompileTime);
 }

-} //  serialization
-} //  boost
+} // namespace serialization
+} // namespace boost

 ////////////////////////////////////////////////////////////////////////////////

@@ -87,28 +83,30 @@ void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCo
 // this is needed by boost::lexical_cast to cope with Eigens Vectors ///////////
 namespace Eigen {
 template <typename T, int size>
-std::istream & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
+std::istream &operator>>(std::istream &is, Eigen::Matrix<T, size, 1> &vec) {
  std::string str;
-    for( unsigned int i=0; i<size; i++) {
+  for (unsigned int i = 0; i < size; i++) {
    is >> std::skipws;
    is >> str;
-        if(is.fail()) vec(i) = 0;
-        else vec(i) = boost::lexical_cast<T>(str);
+    if (is.fail())
+      vec(i) = 0;
+    else
+      vec(i) = boost::lexical_cast<T>(str);
  }
  return is;
 }
 template <typename T, int size>
-std::ostream & operator << (std::ostream &os, const Eigen::Matrix<T,size,1> &vec) {
+std::ostream &operator<<(std::ostream &os,
+                         const Eigen::Matrix<T, size, 1> &vec) {
  os << vec.transpose();
  return os;
 }
-} // Eigen
+} // namespace Eigen
 ////////////////////////////////////////////////////////////////////////////////

-
-
 namespace uLib {

+typedef id_t Id_t;

 typedef int Scalari;
 typedef unsigned int Scalarui;
@@ -117,29 +115,39 @@ typedef unsigned long Scalarul;
 typedef float Scalarf;
 typedef double Scalard;

-
-
-typedef Eigen::Matrix<int,1,1> Matrix1i;
-typedef Eigen::Matrix2i Matrix2i;
-typedef Eigen::Matrix3i Matrix3i;
-typedef Eigen::Matrix4i Matrix4i;
-
-typedef Eigen::Matrix<float,1,1> Matrix1f;
-typedef Eigen::Matrix2f Matrix2f;
-typedef Eigen::Matrix3f Matrix3f;
-typedef Eigen::Matrix4f Matrix4f;
-
-typedef Eigen::Matrix<int,1,1> Vector1i;
+typedef Eigen::Matrix<int, 1, 1> Vector1i;
 typedef Eigen::Vector2i Vector2i;
 typedef Eigen::Vector3i Vector3i;
 typedef Eigen::Vector4i Vector4i;

-typedef Eigen::Matrix<float,1,1> Vector1f;
+typedef Eigen::Matrix<float, 1, 1> Vector1f;
 typedef Eigen::Vector2f Vector2f;
 typedef Eigen::Vector3f Vector3f;
 typedef Eigen::Vector4f Vector4f;

+typedef Eigen::Matrix<double, 1, 1> Vector1d;
+typedef Eigen::Vector2d Vector2d;
+typedef Eigen::Vector3d Vector3d;
+typedef Eigen::Vector4d Vector4d;

+typedef Eigen::Matrix<int, 1, 1> Matrix1i;
+typedef Eigen::Matrix2i Matrix2i;
+typedef Eigen::Matrix3i Matrix3i;
+typedef Eigen::Matrix4i Matrix4i;
+
+typedef Eigen::Matrix<float, 1, 1> Matrix1f;
+typedef Eigen::Matrix2f Matrix2f;
+typedef Eigen::Matrix3f Matrix3f;
+typedef Eigen::Matrix4f Matrix4f;
+
+typedef Eigen::Matrix<double, 1, 1> Matrix1d;
+typedef Eigen::Matrix2d Matrix2d;
+typedef Eigen::Matrix3d Matrix3d;
+typedef Eigen::Matrix4d Matrix4d;
+
+typedef Eigen::MatrixXi MatrixXi;
+typedef Eigen::MatrixXf MatrixXf;
+typedef Eigen::MatrixXd MatrixXd;


 ////////////////////////////////////////////////////////////////////////////////
@@ -147,134 +155,125 @@ typedef Eigen::Vector4f Vector4f;
 ////////////////////////////////////////////////////////////////////////////////

 /*! Given a string consisting of a series of doubles with some
-*  delimiter, return an Eigen::Vector populated with those
-*  values, in the same order as they are given in the string.
-*
-*  \param vec A double vector to be populated with the results
-*  \param str A string to be parsed as a series of doubles.
-*  \param delim Delimiters of the text (a typical default is " ," for comma and space-delimited text
-*
-*/
+ *  delimiter, return an Eigen::Vector populated with those
+ *  values, in the same order as they are given in the string.
+ *
+ *  \param vec A double vector to be populated with the results
+ *  \param str A string to be parsed as a series of doubles.
+ *  \param delim Delimiters of the text (a typical default is " ," for comma and
+ * space-delimited text
+ *
+ */
 template <typename T, int size>
-void VectorxT_StringTo(Eigen::Matrix<T,size,1> &vec, std::string str, const char *delim = " ,;\t\n") {
+void VectorxT_StringTo(Eigen::Matrix<T, size, 1> &vec, std::string str,
+                       const char *delim = " ,;\t\n") {
  std::vector<std::string> strvec;

-    boost::algorithm::trim_if( str, boost::algorithm::is_any_of(delim));
-    boost::algorithm::split(strvec,str,boost::algorithm::is_any_of(delim), boost::algorithm::token_compress_on);
+  boost::algorithm::trim_if(str, boost::algorithm::is_any_of(delim));
+  boost::algorithm::split(strvec, str, boost::algorithm::is_any_of(delim),
+                          boost::algorithm::token_compress_on);

-    for( unsigned int i=0; i<size; i++) {
+  for (unsigned int i = 0; i < size; i++) {
    vec(i) = boost::lexical_cast<T>(strvec[i]);
  }
 }

 template <typename T, int size>
-std::string VectorxT_ToString(const Eigen::Matrix<T,size,1> &vec) {
+std::string VectorxT_ToString(const Eigen::Matrix<T, size, 1> &vec) {
  std::stringstream sst;
  sst << vec.transpose();
  return sst.str();
 }

-
-//template <typename T, int size>
-//Eigen::Matrix<T,size,1> & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
-//}
+// template <typename T, int size>
+// Eigen::Matrix<T,size,1> & operator >> (std::istream &is,
+// Eigen::Matrix<T,size,1> &vec) {
+// }

 template <typename T, int size>
-void operator>> (std::string& str, Eigen::Matrix<T,size,1> &vec){
-    VectorxT_StringTo(vec,str);
+void operator >> (std::string &str, Eigen::Matrix<T, size, 1> &vec) {
+  VectorxT_StringTo(vec, str);
 }

-
 ////////////////////////////////////////////////////////////////////////////////
 //////   HOMOGENEOUS VECTORS  //////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-template <bool p>
-class _HPoint3f : public Eigen::Matrix< Scalarf,4,1 > {
+template <bool p> class _HPoint3f : public Eigen::Matrix<Scalarf, 4, 1> {
 public:
-    typedef Eigen::Matrix< Scalarf,4,1 > BaseClass;
+  typedef Eigen::Matrix<Scalarf, 4, 1> BaseClass;

-    _HPoint3f<p>() : BaseClass(0,0,0,p) {}
-    _HPoint3f<p>(float x,float y,float z) : BaseClass(x,y,z,p) {}
-    _HPoint3f<p>(Vector3f &in) : BaseClass(in.homogeneous()) { this->operator()(3) = p; }
+  _HPoint3f() : BaseClass(0, 0, 0, p) {}
+  _HPoint3f(int rows, int cols) : BaseClass() {
+    this->operator()(3) = p;
+  }
+  _HPoint3f(float x, float y, float z) : BaseClass(x, y, z, p) {}
+  _HPoint3f(Vector3f &in) : BaseClass(in.homogeneous()) {
+    this->operator()(3) = p;
+  }

-    void operator delete(void* _p, size_t _s) {}
+  void operator delete(void *_p, size_t _s) {}

  // This constructor allows to construct MyVectorType from Eigen expressions
-    template<typename OtherDerived>
-    inline _HPoint3f<p>(const Eigen::MatrixBase<OtherDerived>& other)
-        : BaseClass(other)
-    { }
+  template <typename OtherDerived>
+  inline _HPoint3f(const Eigen::MatrixBase<OtherDerived> &other)
+      : BaseClass(other) {}

  // This method allows to assign Eigen expressions to Vector3H
-    template<typename OtherDerived>
-    inline _HPoint3f<p> & operator= (const Eigen::MatrixBase <OtherDerived>& other)
-    {
+  template <typename OtherDerived>
+  inline _HPoint3f &operator=(const Eigen::MatrixBase<OtherDerived> &other) {
    this->BaseClass::operator=(other);
    return *this;
  }
-
 };
 typedef _HPoint3f<false> HVector3f;
 typedef _HPoint3f<true> HPoint3f;

-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 //////   HOMOGENEOUS LINE     //////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-
-struct _HLine3f
-{
+struct _HLine3f {
  HPoint3f origin;
  HVector3f direction;
 };
 typedef struct _HLine3f HLine3f;

-inline std::ostream&
-operator<< (std::ostream& stream, const HLine3f &line) {
-    stream << "HLine3f(" << "pt[" << line.origin.transpose() <<"] , dr[" << line.direction.transpose() << "]) ";
+inline std::ostream &operator<<(std::ostream &stream, const HLine3f &line) {
+  stream << "HLine3f(" << "pt[" << line.origin.transpose() << "] , dr["
+         << line.direction.transpose() << "]) ";
  return stream;
 }

-
-
-
-struct _HError3f
-{
+struct _HError3f {
  HVector3f position_error;
  HVector3f direction_error;
 };
 typedef struct _HError3f HError3f;

-inline std::ostream&
-operator<< (std::ostream& stream, const HError3f &err) {
-    stream << "HError3f(" << "ept[" << err.position_error.transpose() <<"] , edr[" << err.direction_error.transpose() << "]) ";
+inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
+  stream << "HError3f(" << "ept[" << err.position_error.transpose()
+         << "] , edr[" << err.direction_error.transpose() << "]) ";
  return stream;
 }

-
-}
-
+} // namespace uLib

 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // SERIALIZTION //

+#ifdef ULIB_SERIALIZATION_ON
+#include "Core/Serializable.h"
+
 ULIB_SERIALIZABLE(uLib::HPoint3f)

 ULIB_SERIALIZABLE(uLib::HVector3f)

-
 ULIB_SERIALIZABLE(uLib::HLine3f)

 ULIB_SERIALIZABLE(uLib::HError3f)
-
-
-
-
+#endif // ULIB_SERIALIZATION_ON

 #endif // U_DENSEMATRIX_H
--- a/src/Math/Geometry.h
+++ b/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"

--- a/src/Math/Quote.h
+++ b/src/Math/Quote.h
@@ -32,11 +32,11 @@

 namespace uLib {

-class Quote : public Vector2f {
+class Quote : public Vector2f
+{
 public:

-
-    uLibRefMacro(Offset,Scalarf);
+    inline Scalarf& Offset() { return this->m_Offset; }

 private:
    Scalarf m_Offset;
--- a/src/Math/Structured2DGrid.cpp
+++ b/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";
+}
+
--- a/src/Math/Structured2DGrid.h
+++ b/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
--- a/src/Math/Structured4DGrid.cpp
+++ b/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";
+}
+
--- a/src/Math/Structured4DGrid.h
+++ b/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
--- a/src/Math/StructuredData.h
+++ b/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;

--- a/src/Math/StructuredGrid.h
+++ b/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"

--- a/src/Math/Transform.h
+++ b/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(); }
@@ -108,6 +110,17 @@ public:

    inline void Rotate(const Matrix3f &m) { this->m_T.rotate(m); }

+    inline void Rotate(const float angle, Vector3f axis)
+    {
+        axis.normalize(); // prehaps not necessary ( see eigens )
+        Eigen::AngleAxisf ax(angle,axis);
+        this->m_T.rotate(Eigen::Quaternion<float>(ax));
+    }
+
+    inline void Rotate(const Vector3f euler_axis) {
+        float angle = euler_axis.norm();
+        Rotate(angle,euler_axis);
+    }

    inline void PreRotate(const Matrix3f &m) { this->m_T.prerotate(m); }

--- a/src/Math/TriangleMesh.h
+++ b/src/Math/TriangleMesh.h
@@ -28,14 +28,14 @@
 #ifndef TRIANGLEMESH_H
 #define TRIANGLEMESH_H

-#include "Core/Object.h"
-#include "Core/Vector.h"
+#include <vector>
+
 #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>)
-    uLibRefMacro(Triangles,Vector<Vector3i>)
+    inline std::vector<Vector3f> & Points() { return this->m_Points; }
+    inline std::vector<Vector3i> & Triangles() { return this->m_Triangles; }

 private:
-    Vector<Vector3f> m_Points;
-    Vector<Vector3i> m_Triangles;
+    std::vector<Vector3f> m_Points;
+    std::vector<Vector3i> m_Triangles;

 };

--- a/src/Math/VoxImage.cpp
+++ b/src/Math/VoxImage.cpp
@@ -30,6 +30,13 @@

 #include "VoxImage.h"

+#include <vtkSmartPointer.h>
+#include <vtkImageData.h>
+#include <vtkXMLImageDataReader.h>
+#include <vtkXMLImageDataWriter.h>
+#include <vtkStringArray.h>
+#include <vtkInformation.h>
+#include <vtkInformationStringKey.h>

 namespace uLib {

@@ -83,7 +90,103 @@ void Abstract::VoxImage::ExportToVtk (const char *file, bool density_type)
    printf("%s vtk file saved\n",file);
 }

-int Abstract::VoxImage::ImportFromVtk(const char *file)
+
+
+void Abstract::VoxImage::ExportToVti (const char *file, bool density_type, bool compressed)
+{
+    Abstract::VoxImage *voxels = this;
+
+    vtkSmartPointer<vtkImageData> image = vtkSmartPointer<vtkImageData>::New();
+    image->SetDimensions(voxels->GetDims()(0), voxels->GetDims()(1), voxels->GetDims()(2));
+    image->SetSpacing(voxels->GetSpacing()(0), voxels->GetSpacing()(1), voxels->GetSpacing()(2));
+    image->SetOrigin(voxels->GetPosition()(0), voxels->GetPosition()(1), voxels->GetPosition()(2));
+    image->AllocateScalars(VTK_FLOAT, 1);
+
+    float norm;
+    if (density_type) {
+        norm = 1;
+    } else norm = 1.E6;
+
+    int nx = voxels->GetDims()(0);
+    int ny = voxels->GetDims()(1);
+    int nz = voxels->GetDims()(2);
+
+    size_t npoints = nx*ny*nz;
+    float *scalar = static_cast<float*>(image->GetScalarPointer());
+
+    StructuredData unwrap(*voxels);
+    unwrap.SetDataOrder(StructuredData::XYZ); // move to XYZ order (VTK)
+    for (size_t i = 0; i < npoints; i++) {
+        Vector3i idx = unwrap.UnMap(i);
+        scalar[i] = static_cast<float>(voxels->GetValue(idx) * norm);
+    }
+
+    // Create a custom string key
+    static vtkInformationStringKey* ConfigNote =
+        vtkInformationStringKey::MakeKey("cmt.config", "Config");
+
+    // Attach metadata
+    vtkInformation *info = image->GetInformation();
+    info->Set(ConfigNote, 
+
+    "This image was generated with uLib\n"
+    "-----------------------------------\n"
+    "Author: Andrea Rigoni\n"
+    "Version: 0.1\n"
+    "Date: 2025\n"
+
+    );
+
+    // std::cout << info->Get(ConfigNote) << std::endl;
+    vtkSmartPointer<vtkXMLImageDataWriter> writer = vtkSmartPointer<vtkXMLImageDataWriter>::New();
+    writer->SetFileName(file);
+    writer->SetInputData(image);
+    if(compressed) {
+        writer->SetDataModeToBinary();
+        writer->SetCompressorTypeToZLib();
+    }
+    writer->Write();
+}
+
+
+int Abstract::VoxImage::ImportFromVti(const char *file, bool density_type) {
+    
+    vtkSmartPointer<vtkXMLImageDataReader> reader = vtkSmartPointer<vtkXMLImageDataReader>::New();
+    reader->SetFileName(file);
+    reader->Update();
+    vtkImageData *image = reader->GetOutput();
+    if(!image) return false;
+    
+    Abstract::VoxImage *voxels = this;
+    int nx = image->GetDimensions()[0];
+    int ny = image->GetDimensions()[1];
+    int nz = image->GetDimensions()[2];
+    
+    voxels->SetDims(Vector3i(nx,ny,nz));
+    voxels->SetSpacing(Vector3f(image->GetSpacing()[0],image->GetSpacing()[1],image->GetSpacing()[2]));
+    voxels->SetPosition(Vector3f(image->GetOrigin()[0],image->GetOrigin()[1],image->GetOrigin()[2]));
+
+    float norm;
+    if (density_type) {
+        norm = 1;
+    } else norm = 1.E6;
+
+    size_t npoints = nx*ny*nz;
+    float *scalar = static_cast<float*>(image->GetScalarPointer());
+
+    StructuredData wrap(*voxels);
+    wrap.SetDataOrder(StructuredData::XYZ);
+    for (size_t i = 0; i < npoints; i++) {
+        Vector3i idx = wrap.UnMap(i);
+        voxels->SetValue(idx, scalar[i] / norm);
+    }
+
+    return true;
+}
+
+
+
+int Abstract::VoxImage::ImportFromVtk(const char *file, bool density_type)
 {
    FILE * vtk_file = fopen(file, "r");
    if (!vtk_file) return false;
@@ -115,14 +218,18 @@ int Abstract::VoxImage::ImportFromVtk(const char *file)
    this->SetSpacing(Vector3f(sx,sy,sz));
    this->SetPosition(Vector3f(ox,oy,oz));

+    float norm;
+    if (density_type) {
+        norm = 1;
+    } else norm = 1.E6;
+
    for (int k = 0; k < dz; ++k) {
        for (int j = 0; j < dy; ++j) {
            for (int i = 0; i < dx; ++i) {
                Vector3i idx(i, j, k);
                float tmp_val;
                fscanf(vtk_file, "%f", &tmp_val);
-                //this->SetValue(idx,fabs(tmp_val)*1E-6);
-                this->SetValue(idx,tmp_val*1E-6);
+                this->SetValue(idx,tmp_val / norm);
            }
        }
    }
--- a/src/Math/VoxImage.h
+++ b/src/Math/VoxImage.h
@@ -23,18 +23,18 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #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>
+
+#include <Core/DataAllocator.h>

 namespace uLib {

@@ -56,16 +56,26 @@ public:
  virtual void SetDims(const Vector3i &size) = 0;

  void ExportToVtk(const char *file, bool density_type = 0);
-    void ExportToVtkXml(const char *file, bool density_type = 0);
-    int ImportFromVtk(const char *file);

-protected:
+  // use this function to export to VTK binary format
+  void ExportToVti(const char *file, bool density_type = 0,
+                   bool compressed = 0);
+
+  // this function has been deprecated in favor of ExportToVti
+  // but it is kept for backward compatibility and because it
+  // does not depend on vtk library
+  void ExportToVtkXml(const char *file, bool density_type = 0);
+
+  int ImportFromVtk(const char *file, bool density_type = 0);
+
+  int ImportFromVti(const char *file, bool density_type = 0);

  virtual ~VoxImage() {}
+protected:
  VoxImage(const Vector3i &size) : BaseClass(size) {}
 };

-}
+} // namespace Abstract

 ////////////////////////////////////////////////////////////////////////////////
 //  VOXEL   ////////////////////////////////////////////////////////////////////
@@ -73,24 +83,22 @@ protected:

 namespace Interface {
 struct Voxel {
-    template<class Self> void check_structural() {
-        uLibCheckMember(Self,Value, Scalarf);
+  template <class Self> void check_structural() {
+    uLibCheckMember(Self, Value, Scalarf);
  }
 };
-}
+} // namespace Interface

 struct Voxel {
-    Scalarf      Value;
+  Scalarf Value = 0.0f;
+  Scalari Count = 0;
 };

-
 ////////////////////////////////////////////////////////////////////////////////
 //  VOX IMAGE  /////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

-
-template< typename T >
-class VoxImage :  public Abstract::VoxImage {
+template <typename T> class VoxImage : public Abstract::VoxImage {
 public:
  typedef Abstract::VoxImage BaseClass;

@@ -98,50 +106,53 @@ public:

  VoxImage(const Vector3i &size);

-    VoxImage(const VoxImage<T> &copy) :
-        BaseClass(copy)
-    {
+  VoxImage(const VoxImage<T> &copy) : BaseClass(copy) {
    this->m_Data = copy.m_Data;
  }

-    uLibRefMacro(Data,Vector<T>)
-    inline const Vector<T>& ConstData() const { return m_Data; }
+  inline DataAllocator<T> &Data() { return this->m_Data; }
+  inline const DataAllocator<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)); }
-    inline T& operator[](unsigned int i)     { return m_Data[i]; }
-    inline T& operator[](const Vector3i &id) { return m_Data[Map(id)]; }
+  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)); }
+  inline T &operator[](unsigned int i) { return m_Data[i]; }
+  inline T &operator[](const Vector3i &id) { return m_Data[Map(id)]; }

  // this implements Abstract interface //
  inline Scalarf GetValue(const Vector3i &id) const {
    return this->At(id).Value;
  }
-    inline Scalarf GetValue(const int id) const {
-        return this->At(id).Value;
-    }
+  inline Scalarf GetValue(const int id) const { return this->At(id).Value; }

  inline void SetValue(const Vector3i &id, Scalarf value) {
-        this->operator [](id).Value = value;
+    this->operator[](id).Value = value;
  }
  inline void SetValue(const int id, float value) {
-        this->operator [](id).Value = value;
+    this->operator[](id).Value = value;
  }

  inline void SetDims(const Vector3i &size) {
    this->m_Data.resize(size.prod());
-        BaseClass::BaseClass::SetDims(size); // FIX horrible coding style !
+    StructuredGrid::SetDims(size);
  }

  inline VoxImage<T> clipImage(const Vector3i begin, const Vector3i end) const;
  inline VoxImage<T> clipImage(const HPoint3f begin, const HPoint3f end) const;
  inline VoxImage<T> clipImage(const float density) const;
-    inline VoxImage<T> clipImage(const float densityMin, const float densityMax) const;
+  inline VoxImage<T> clipImage(const float densityMin,
+                               const float densityMax) const;

-    inline VoxImage<T> maskImage(const HPoint3f begin, const HPoint3f end, float value) const;
-    inline VoxImage<T> maskImage(const float threshold, float belowValue=0, float aboveValue=0) const;
+  inline VoxImage<T> maskImage(const HPoint3f begin, const HPoint3f end,
+                               float value) const;
+  inline VoxImage<T> maskImage(const float threshold, float belowValue = 0,
+                               float aboveValue = 0) const;
  inline VoxImage<T> fixVoxels(const float threshold, float tolerance) const;
-    inline VoxImage<T> fixVoxels(const float threshold, float tolerance, const HPoint3f begin, const HPoint3f end) const;
-    inline VoxImage<T> fixVoxelsAroundPlane(const float threshold, float tolerance, const HPoint3f begin, const HPoint3f end, bool aboveAir) const;
+  inline VoxImage<T> fixVoxels(const float threshold, float tolerance,
+                               const HPoint3f begin, const HPoint3f end) const;
+  inline VoxImage<T> fixVoxelsAroundPlane(const float threshold,
+                                          float tolerance, const HPoint3f begin,
+                                          const HPoint3f end,
+                                          bool aboveAir) const;
  inline VoxImage<T> fixVoxels(const HPoint3f begin, const HPoint3f end) const;
  inline VoxImage<T> Abs() const;

@@ -150,145 +161,137 @@ public:
  inline void InitVoxels(T t);

  // MATH OPERATORS //
-    inline void operator *=(Scalarf scalar) {
-        for(unsigned int i = 0; i < m_Data.size(); ++i)
+  inline void operator*=(Scalarf scalar) {
+    for (unsigned int i = 0; i < m_Data.size(); ++i)
      m_Data[i].Value *= scalar;
  }
-    inline void operator +=(Scalarf scalar) {
-        for(unsigned int i = 0; i < m_Data.size(); ++i)
+  inline void operator+=(Scalarf scalar) {
+    for (unsigned int i = 0; i < m_Data.size(); ++i)
      m_Data[i].Value += scalar;
  }
-    inline void operator /=(Scalarf scalar) {
-        for(unsigned int i = 0; i < m_Data.size(); ++i)
+  inline void operator/=(Scalarf scalar) {
+    for (unsigned int i = 0; i < m_Data.size(); ++i)
      m_Data[i].Value /= scalar;
  }
-    inline void operator -=(Scalarf scalar) {
-        for(unsigned int i = 0; i < m_Data.size(); ++i)
+  inline void operator-=(Scalarf scalar) {
+    for (unsigned int i = 0; i < m_Data.size(); ++i)
      m_Data[i].Value -= scalar;
  }

  // MATH VoxImage Operators //
-    template <typename S>
-    void operator +=(VoxImage<S> &sibling) {
+  template <typename S> void operator+=(VoxImage<S> &sibling) {
    if (this->GetDims() != sibling.GetDims()) {
-            //printf("Warning when adding VoxImages: I'm NOT doing it!\n");
+      // printf("Warning when adding VoxImages: I'm NOT doing it!\n");
      return;
-        }// WARNING! You must Warn the user!
-        for(unsigned int i = 0; i < m_Data.size(); ++i) {
+    } // WARNING! You must Warn the user!
+    for (unsigned int i = 0; i < m_Data.size(); ++i) {
      m_Data[i].Value += sibling.At(i).Value;
    }
  }

-    template <typename S>
-    void operator -=(VoxImage<S> &sibling) {
+  template <typename S> void operator-=(VoxImage<S> &sibling) {
    if (this->GetDims() != sibling.GetDims()) {
-            //printf("Warning when subtracting VoxImages: I'm NOT doing it!\n");
+      // printf("Warning when subtracting VoxImages: I'm NOT doing it!\n");
      return;
-        }// WARNING! You must Warn the user!
-        for(unsigned int i = 0; i < m_Data.size(); ++i) {
+    } // WARNING! You must Warn the user!
+    for (unsigned int i = 0; i < m_Data.size(); ++i) {
      m_Data[i].Value -= sibling.At(i).Value;
    }
  }

-    template <typename S>
-    void operator *=(VoxImage<S> &sibling) {
+  template <typename S> void operator*=(VoxImage<S> &sibling) {
    if (this->GetDims() != sibling.GetDims()) {
-            //printf("Warning when multiplying VoxImages: I'm NOT doing it!\n");
+      // printf("Warning when multiplying VoxImages: I'm NOT doing it!\n");
      return;
-        }// WARNING! You must Warn the user!
-        for(unsigned int i = 0; i < m_Data.size(); ++i) {
+    } // WARNING! You must Warn the user!
+    for (unsigned int i = 0; i < m_Data.size(); ++i) {
      m_Data[i].Value *= sibling.At(i).Value;
    }
  }

-    template <typename S>
-    void operator /=(VoxImage<S> &sibling) {
+  template <typename S> void operator/=(VoxImage<S> &sibling) {
    if (this->GetDims() != sibling.GetDims()) {
-            //printf("Warning when dividing VoxImages: I'm NOT doing it!\n");
+      // printf("Warning when dividing VoxImages: I'm NOT doing it!\n");
      return;
-        }// WARNING! You must Warn the user!
-        for(unsigned int i = 0; i < m_Data.size(); ++i) {
+    } // WARNING! You must Warn the user!
+    for (unsigned int i = 0; i < m_Data.size(); ++i) {
      m_Data[i].Value /= sibling.At(i).Value;
    }
  }

 private:
-    Vector<T> m_Data;
+  DataAllocator<T> m_Data;
 };

-
-template<typename T>
-VoxImage<T>::VoxImage() :
-    m_Data(0),
-    BaseClass(Vector3i(0,0,0))
-{ Interface::IsA <T,Interface::Voxel>(); /* structural check for T */ }
-
-template<typename T>
-VoxImage<T>::VoxImage(const Vector3i &size) :
-    m_Data(size.prod()),
-    BaseClass(size)
-{ Interface::IsA <T,Interface::Voxel>(); /* structural check for T */ }
-
+template <typename T>
+VoxImage<T>::VoxImage() : m_Data(0), BaseClass(Vector3i(0, 0, 0)) {
+  Interface::IsA<T, Interface::Voxel>(); /* structural check for T */
+}

 template <typename T>
-VoxImage<T> VoxImage<T>::clipImage(const Vector3i begin, const Vector3i end) const
-{
-        Vector3i dim = (end-begin)+Vector3i(1,1,1);
+VoxImage<T>::VoxImage(const Vector3i &size)
+    : m_Data(size.prod()), BaseClass(size) {
+  Interface::IsA<T, Interface::Voxel>(); /* structural check for T */
+}
+
+template <typename T>
+VoxImage<T> VoxImage<T>::clipImage(const Vector3i begin,
+                                   const Vector3i end) const {
+  Vector3i dim = (end - begin) + Vector3i(1, 1, 1);
  VoxImage<T> out(*this);
  out.SetDims(dim);
-        out.SetPosition(this->GetPosition() + this->GetSpacing().cwiseProduct(begin.cast<float>()) );
+  out.SetPosition(this->GetPosition() +
+                  this->GetSpacing().cwiseProduct(begin.cast<float>()));

-        for(uint x = 0; x<dim(0); ++x )
-            for(uint y = 0; y<dim(1); ++y )
-                for(uint z = 0; z<dim(2); ++z )
-                {
-                    Vector3i id = Vector3i(x,y,z);
+  for (uint x = 0; x < dim(0); ++x)
+    for (uint y = 0; y < dim(1); ++y)
+      for (uint z = 0; z < dim(2); ++z) {
+        Vector3i id = Vector3i(x, y, z);
        out[id] = this->At(begin + id);
      }
  return out;
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::clipImage(const HPoint3f begin, const HPoint3f end) const
-{
+VoxImage<T> VoxImage<T>::clipImage(const HPoint3f begin,
+                                   const HPoint3f end) const {
  Vector3i v1 = this->Find(begin);
  Vector3i v2 = this->Find(end);
-    return this->clipImage(v1,v2);
+  return this->clipImage(v1, v2);
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::clipImage(const float density) const
-{
+VoxImage<T> VoxImage<T>::clipImage(const float density) const {
  Vector3i v1 = this->GetDims();
-    Vector3i v2 = Vector3i(0,0,0);
-    for(uint i=0; i< this->m_Data.size(); ++i) {
-        if( this->GetValue(i) >= density ) {
+  Vector3i v2 = Vector3i(0, 0, 0);
+  for (uint i = 0; i < this->m_Data.size(); ++i) {
+    if (this->GetValue(i) >= density) {
      Vector3i id = this->UnMap(i);
      v1 = v1.array().min(id.array());
      v2 = v2.array().max(id.array());
    }
  }
-    return this->clipImage(v1,v2);
+  return this->clipImage(v1, v2);
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::clipImage(const float densityMin, const float densityMax) const
-{
+VoxImage<T> VoxImage<T>::clipImage(const float densityMin,
+                                   const float densityMax) const {
  Vector3i v1 = this->GetDims();
-    Vector3i v2 = Vector3i(0,0,0);
-    for(uint i=0; i< this->m_Data.size(); ++i) {
-        if( this->GetValue(i) >= densityMin && this->GetValue(i) <= densityMax) {
+  Vector3i v2 = Vector3i(0, 0, 0);
+  for (uint i = 0; i < this->m_Data.size(); ++i) {
+    if (this->GetValue(i) >= densityMin && this->GetValue(i) <= densityMax) {
      Vector3i id = this->UnMap(i);
      v1 = v1.array().min(id.array());
      v2 = v2.array().max(id.array());
    }
  }
-    return this->clipImage(v1,v2);
+  return this->clipImage(v1, v2);
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::maskImage(const HPoint3f begin, const HPoint3f end, float value) const
-{
+VoxImage<T> VoxImage<T>::maskImage(const HPoint3f begin, const HPoint3f end,
+                                   float value) const {
  VoxImage<T> out(*this);
  out.SetDims(this->GetDims());
  out.SetPosition(this->GetPosition());
@@ -298,53 +301,54 @@ VoxImage<T> VoxImage<T>::maskImage(const HPoint3f begin, const HPoint3f end, flo

  Vector3i ID;

-    for(int ix=voxB(0); ix<voxE(0); ix++)
-        for(int iy=voxB(1); iy<voxE(1); iy++)
-            for(int iz=voxB(2); iz<voxE(2); iz++){
-                ID << ix,iy,iz;
-                out.SetValue(ID,value*1.E-6);
+  for (int ix = voxB(0); ix < voxE(0); ix++)
+    for (int iy = voxB(1); iy < voxE(1); iy++)
+      for (int iz = voxB(2); iz < voxE(2); iz++) {
+        ID << ix, iy, iz;
+        out.SetValue(ID, value * 1.E-6);
      }

  return out;
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::maskImage(const float threshold, float belowValue, float aboveValue) const
-{
-    std::cout << "VoxImage: maskImage, fixing voxels under threshold " << threshold;
-    if(belowValue)
+VoxImage<T> VoxImage<T>::maskImage(const float threshold, float belowValue,
+                                   float aboveValue) const {
+  std::cout << "VoxImage: maskImage, fixing voxels under threshold "
+            << threshold;
+  if (belowValue)
    std::cout << " at value " << belowValue;
  else
    std::cout << " at -value";
  std::cout << ", voxels above threshold at value ";
-    if(aboveValue)
+  if (aboveValue)
    std::cout << aboveValue;
  else
    std::cout << "found";

-
  VoxImage<T> out(*this);
  out.SetDims(this->GetDims());
  out.SetPosition(this->GetPosition());

-    for(uint i=0; i< this->m_Data.size(); ++i) {
+  for (uint i = 0; i < this->m_Data.size(); ++i) {
    // skip negative voxels: they are already frozen
-        if( this->GetValue(i) >= 0 ){
+    if (this->GetValue(i) >= 0) {
      // voxels under threshold
-            if( this->GetValue(i) <= threshold*1.E-6 ){
-                if(belowValue){
-                    //                std::cout << "vox " << i << ", " << this->GetValue(i);
-                    //                std::cout << " ----> set to " << -1.*belowValue*1.E-6 << std::endl;
-                    out.SetValue(i,-1.*belowValue*1.E-6);}
-                else
-                    out.SetValue(i,-1.*this->GetValue(i));
+      if (this->GetValue(i) <= threshold * 1.E-6) {
+        if (belowValue) {
+          //                std::cout << "vox " << i << ", " <<
+          //                this->GetValue(i); std::cout << " ----> set to " <<
+          //                -1.*belowValue*1.E-6 << std::endl;
+          out.SetValue(i, -1. * belowValue * 1.E-6);
+        } else
+          out.SetValue(i, -1. * this->GetValue(i));
      }
      // voxels over threshold
-            else{
-                if(aboveValue)
-                    out.SetValue(i,aboveValue*1.E-6);
+      else {
+        if (aboveValue)
+          out.SetValue(i, aboveValue * 1.E-6);
        else
-                    out.SetValue(i,this->GetValue(i));
+          out.SetValue(i, this->GetValue(i));
      }
    }
  }
@@ -352,43 +356,43 @@ VoxImage<T> VoxImage<T>::maskImage(const float threshold, float belowValue, floa
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::fixVoxels(const float threshold, float tolerance) const
-{
+VoxImage<T> VoxImage<T>::fixVoxels(const float threshold,
+                                   float tolerance) const {
  std::cout << "VoxImage: fixing voxels with value " << threshold << std::endl;

  VoxImage<T> out(*this);
  out.SetDims(this->GetDims());
  out.SetPosition(this->GetPosition());

-    for(uint i=0; i< this->m_Data.size(); ++i) {
+  for (uint i = 0; i < this->m_Data.size(); ++i) {
    // voxels around threshold
-        if( fabs(this->GetValue(i) - threshold*1.E-6) < tolerance* 1.E-6 ){
-//            std::cout << "vox " << i << ", " << this->GetValue(i);
-//            std::cout << " ----> set to " << -1.*this->GetValue(i) << std::endl;
-                out.SetValue(i,-1.*this->GetValue(i));
+    if (fabs(this->GetValue(i) - threshold * 1.E-6) < tolerance * 1.E-6) {
+      //            std::cout << "vox " << i << ", " << this->GetValue(i);
+      //            std::cout << " ----> set to " << -1.*this->GetValue(i) <<
+      //            std::endl;
+      out.SetValue(i, -1. * this->GetValue(i));
    }
  }
  return out;
 }

-template <typename T>
-VoxImage<T> VoxImage<T>::Abs() const
-{
+template <typename T> VoxImage<T> VoxImage<T>::Abs() const {
  std::cout << "VoxImage: set abs voxels value " << std::endl;

  VoxImage<T> out(*this);
  out.SetDims(this->GetDims());
  out.SetPosition(this->GetPosition());

-    for(uint i=0; i< this->m_Data.size(); ++i)
-        out.SetValue(i,fabs(this->GetValue(i)));
+  for (uint i = 0; i < this->m_Data.size(); ++i)
+    out.SetValue(i, fabs(this->GetValue(i)));

  return out;
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::fixVoxels( const float threshold, float tolerance, const HPoint3f begin, const HPoint3f end) const
-{
+VoxImage<T> VoxImage<T>::fixVoxels(const float threshold, float tolerance,
+                                   const HPoint3f begin,
+                                   const HPoint3f end) const {
  VoxImage<T> out(*this);
  out.SetDims(this->GetDims());
  out.SetPosition(this->GetPosition());
@@ -398,13 +402,13 @@ VoxImage<T> VoxImage<T>::fixVoxels( const float threshold, float tolerance, cons

  Vector3i ID;

-    for(int ix=voxB(0); ix<voxE(0); ix++)
-        for(int iy=voxB(1); iy<voxE(1); iy++)
-            for(int iz=voxB(2); iz<voxE(2); iz++){
-                ID << ix,iy,iz;
+  for (int ix = voxB(0); ix < voxE(0); ix++)
+    for (int iy = voxB(1); iy < voxE(1); iy++)
+      for (int iz = voxB(2); iz < voxE(2); iz++) {
+        ID << ix, iy, iz;
        // voxels around threshold
-                if( fabs(this->GetValue(ID) - threshold*1.E-6) < tolerance*1.E-6 ){
-                    out.SetValue(ID,-1.*this->GetValue(ID));
+        if (fabs(this->GetValue(ID) - threshold * 1.E-6) < tolerance * 1.E-6) {
+          out.SetValue(ID, -1. * this->GetValue(ID));
        }
      }

@@ -412,8 +416,8 @@ VoxImage<T> VoxImage<T>::fixVoxels( const float threshold, float tolerance, cons
 }

 template <typename T>
-VoxImage<T> VoxImage<T>::fixVoxels(const HPoint3f begin, const HPoint3f end) const
-{
+VoxImage<T> VoxImage<T>::fixVoxels(const HPoint3f begin,
+                                   const HPoint3f end) const {
  VoxImage<T> out(*this);
  out.SetDims(this->GetDims());
  out.SetPosition(this->GetPosition());
@@ -423,20 +427,21 @@ VoxImage<T> VoxImage<T>::fixVoxels(const HPoint3f begin, const HPoint3f end) con

  Vector3i ID;

-    for(int ix=voxB(0); ix<voxE(0); ix++)
-        for(int iy=voxB(1); iy<voxE(1); iy++)
-            for(int iz=voxB(2); iz<voxE(2); iz++){
-                ID << ix,iy,iz;
+  for (int ix = voxB(0); ix < voxE(0); ix++)
+    for (int iy = voxB(1); iy < voxE(1); iy++)
+      for (int iz = voxB(2); iz < voxE(2); iz++) {
+        ID << ix, iy, iz;
        // voxels around threshold
-                out.SetValue(ID,-1.*this->GetValue(ID));
+        out.SetValue(ID, -1. * this->GetValue(ID));
      }
  return out;
 }

-
 template <typename T>
-VoxImage<T> VoxImage<T>::fixVoxelsAroundPlane( const float threshold, float tolerance, const HPoint3f B, const HPoint3f E, bool aboveAir) const
-{
+VoxImage<T> VoxImage<T>::fixVoxelsAroundPlane(const float threshold,
+                                              float tolerance, const HPoint3f B,
+                                              const HPoint3f E,
+                                              bool aboveAir) const {
  VoxImage<T> out(*this);
  Vector3i dim = this->GetDims();
  out.SetDims(dim);
@@ -445,49 +450,49 @@ VoxImage<T> VoxImage<T>::fixVoxelsAroundPlane( const float threshold, float tole
  HPoint3f Bcoll = this->GetPosition().homogeneous();

  Vector3i ID;
-    for(int ix=0; ix<dim(0); ix++)
-        for(int iy=0; iy<dim(1); iy++)
-            for(int iz=0; iz<dim(2); iz++){
-                ID << ix,iy,iz;
+  for (int ix = 0; ix < dim(0); ix++)
+    for (int iy = 0; iy < dim(1); iy++)
+      for (int iz = 0; iz < dim(2); iz++) {
+        ID << ix, iy, iz;

        // B, E voxel position
-                Vector3i iv(ix,iy,iz);
-                Vector3f v = Vector3f(iv.cast<float>().cwiseProduct(this->GetSpacing()));
+        Vector3i iv(ix, iy, iz);
+        Vector3f v =
+            Vector3f(iv.cast<float>().cwiseProduct(this->GetSpacing()));
        HPoint3f Bvox = Bcoll + HPoint3f(v);
        HPoint3f Evox = Bvox + this->GetSpacing().homogeneous();
-                HPoint3f V = Bvox + 0.5*(this->GetSpacing().homogeneous());
+        HPoint3f V = Bvox + 0.5 * (this->GetSpacing().homogeneous());

-                // if distance point (x0,y0) from line by points (x1,y1) and (x2,y2) is less than tolerance
+        // if distance point (x0,y0) from line by points (x1,y1) and (x2,y2) is
+        // less than tolerance
        float x1 = B[1];
        float y1 = B[2];
        float x2 = E[1];
        float y2 = E[2];
        float x0 = V[1];
        float y0 = V[2];
-                float dist = fabs( (x2-x1)*(y1-y0) - ((x1-x0)*(y2-y1))) / sqrt( (x2-x1)*(x2-x1)+((y2-y1)*(y2-y1)));
-                float distSign = (x2-x1)*(y1-y0) - ((x1-x0)*(y2-y1));
+        float dist = fabs((x2 - x1) * (y1 - y0) - ((x1 - x0) * (y2 - y1))) /
+                     sqrt((x2 - x1) * (x2 - x1) + ((y2 - y1) * (y2 - y1)));
+        float distSign = (x2 - x1) * (y1 - y0) - ((x1 - x0) * (y2 - y1));

        // set voxel air value
-                if(dist < tolerance){
-                    //std::cout << "voxel " << iv << ", line " << dist << ", tolerance " << tolerance << std::endl;
-                    out.SetValue(ID,threshold*1.E-6);
-                }
-                else
-                    out.SetValue(ID,this->GetValue(ID));
+        if (dist < tolerance) {
+          // std::cout << "voxel " << iv << ", line " << dist << ", tolerance "
+          // << tolerance << std::endl;
+          out.SetValue(ID, threshold * 1.E-6);
+        } else
+          out.SetValue(ID, this->GetValue(ID));

-                if((distSign>0 && aboveAir) || (distSign<0 && !aboveAir)  )
-                    out.SetValue(ID,threshold*1.E-6);
+        if ((distSign > 0 && aboveAir) || (distSign < 0 && !aboveAir))
+          out.SetValue(ID, threshold * 1.E-6);
      }
  return out;
 }

-
-template<typename T>
-void VoxImage<T>::InitVoxels(T t)
-{
-    std::fill( m_Data.begin(), m_Data.end(), t ); // warning... stl function //
+template <typename T> void VoxImage<T>::InitVoxels(T t) {
+  std::fill(m_Data.begin(), m_Data.end(), t); // warning... stl function //
 }

-}
+} // namespace uLib

 #endif // VOXIMAGE_H
--- a/src/Math/VoxImageFilter.h
+++ b/src/Math/VoxImageFilter.h
@@ -23,32 +23,26 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTER_H
 #define VOXIMAGEFILTER_H

 #include "Core/StaticInterface.h"
-#include "Core/Object.h"
 #include "Math/Dense.h"

 #include "Math/VoxImage.h"

-
 namespace uLib {

-
 namespace Interface {
 struct VoxImageFilterShape {
  template <class Self> void check_structural() {
-        uLibCheckFunction(Self,operator(),float,float);
-        uLibCheckFunction(Self,operator(),float,const Vector3f&);
+    uLibCheckFunction(Self, operator(), float, float);
+    uLibCheckFunction(Self, operator(), float, const Vector3f &);
  }
 };
-}
-
-template < typename VoxelT > class Kernel;
+} // namespace Interface

+template <typename VoxelT> class Kernel;

 namespace Abstract {
 class VoxImageFilter {
@@ -60,38 +54,36 @@ public:
 protected:
  virtual ~VoxImageFilter() {}
 };
-}
+} // namespace Abstract

-
-template < typename VoxelT, typename AlgorithmT >
-class VoxImageFilter : public Abstract::VoxImageFilter, public Object
-{   
+template <typename VoxelT, typename AlgorithmT>
+class VoxImageFilter : public Abstract::VoxImageFilter {

 public:
  VoxImageFilter(const Vector3i &size);

  void Run();

-    void SetKernelNumericXZY(const Vector<float> &numeric);
+  void SetKernelNumericXZY(const std::vector<float> &numeric);

  void SetKernelSpherical(float (*shape)(float));

-    template < class ShapeT >
-    void SetKernelSpherical( ShapeT shape );
+  template <class ShapeT> void SetKernelSpherical(ShapeT shape);

  void SetKernelWeightFunction(float (*shape)(const Vector3f &));

-    template < class ShapeT >
-    void SetKernelWeightFunction( ShapeT shape );
+  template <class ShapeT> void SetKernelWeightFunction(ShapeT shape);

-    uLibGetMacro(KernelData,Kernel<VoxelT>)
+  inline const Kernel<VoxelT> &GetKernelData() const {
+    return this->m_KernelData;
+  }
+  inline Kernel<VoxelT> &GetKernelData() { return this->m_KernelData; }

-    uLibGetMacro(Image,VoxImage<VoxelT> *)
+  inline VoxImage<VoxelT> *GetImage() const { return this->m_Image; }

  void SetImage(Abstract::VoxImage *image);

 protected:
-
  float Convolve(const VoxImage<VoxelT> &buffer, int index); // remove //

  void SetKernelOffset();
@@ -104,26 +96,18 @@ protected:

 private:
  AlgorithmT *t_Algoritm;
-
 };

-
-
-
-
-
-}
-
+} // namespace uLib

 #endif // VOXIMAGEFILTER_H

 #include "VoxImageFilter.hpp"

-#include "VoxImageFilterLinear.hpp"
-#include "VoxImageFilterThreshold.hpp"
-#include "VoxImageFilterMedian.hpp"
+#include "VoxImageFilter2ndStat.hpp"
 #include "VoxImageFilterABTrim.hpp"
 #include "VoxImageFilterBilateral.hpp"
-#include "VoxImageFilter2ndStat.hpp"
 #include "VoxImageFilterCustom.hpp"
-
+#include "VoxImageFilterLinear.hpp"
+#include "VoxImageFilterMedian.hpp"
+#include "VoxImageFilterThreshold.hpp"
--- a/src/Math/VoxImageFilter.hpp
+++ b/src/Math/VoxImageFilter.hpp
@@ -23,125 +23,104 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTER_HPP
 #define VOXIMAGEFILTER_HPP

-#include <Math/Dense.h>
 #include "Math/StructuredData.h"
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
+#include <Math/Dense.h>

 namespace uLib {

-
 // KERNEL //////////////////////////////////////////////////////////////////////

-template < typename T >
-class Kernel : public StructuredData {
+template <typename T> class Kernel : public StructuredData {
  typedef StructuredData BaseClass;
+
 public:
  Kernel(const Vector3i &size);

-    inline T& operator[](const Vector3i &id) { return m_Data[Map(id)]; }
-    inline T& operator[](const int &id) { return m_Data[id]; }
+  inline T &operator[](const Vector3i &id) { return m_Data[Map(id)]; }
+  inline T &operator[](const int &id) { return m_Data[id]; }
  inline int GetCenterData() const;

-    uLibRefMacro(Data,Vector<T>)
+  inline DataAllocator<T> &Data() { return this->m_Data; }

-    inline const Vector<T>& ConstData() const { return this->m_Data; }
+  inline const DataAllocator<T> &ConstData() const { return this->m_Data; }

  void PrintSelf(std::ostream &o) const;

 private:
-    Vector<T> m_Data;
+  DataAllocator<T> m_Data;
 };

-template < typename T >
-Kernel<T>::Kernel(const Vector3i &size) :
-    BaseClass(size),
-    m_Data(size.prod())
-{
-    Interface::IsA<T,Interface::Voxel>();
+template <typename T>
+Kernel<T>::Kernel(const Vector3i &size) : BaseClass(size), m_Data(size.prod()) {
+  Interface::IsA<T, Interface::Voxel>();
 }

-template < typename T >
-inline int Kernel<T>::GetCenterData() const
-{
+template <typename T> inline int Kernel<T>::GetCenterData() const {
  static int center = Map(this->GetDims() / 2);
  return center;
 }

-template < typename T >
-void Kernel<T>::PrintSelf(std::ostream &o) const
-{
+template <typename T> void Kernel<T>::PrintSelf(std::ostream &o) const {
  o << " Filter Kernel Dump [XZ_Y]: \n";
  Vector3i index;
  o << "\n Value: \n\n"
    << "------------------------------------------------- \n";
-    for (int y = 0 ; y < this->GetDims()(1); ++y ) {
+  for (int y = 0; y < this->GetDims()(1); ++y) {
    o << "[y=" << y << "]\n";
-        for (int z = 0 ; z < this->GetDims()(2); ++z ) {
-            for (int x = 0 ; x < this->GetDims()(0); ++x ) {
-                index << x,y,z;
+    for (int z = 0; z < this->GetDims()(2); ++z) {
+      for (int x = 0; x < this->GetDims()(0); ++x) {
+        index << x, y, z;
        o << m_Data[Map(index)].Value << " ";
-            } o << "\n";
-        } o << " --------------------------------------------------- \n";
+      }
+      o << "\n";
+    }
+    o << " --------------------------------------------------- \n";
  }
  o << "\n Offset: \n"
    << "------------------------------------------------- \n";
-    for (int y = 0 ; y < this->GetDims()(1); ++y ) {
+  for (int y = 0; y < this->GetDims()(1); ++y) {
    o << "[y=" << y << "]\n";
-        for (int z = 0 ; z < this->GetDims()(2); ++z ) {
-            for (int x = 0 ; x < this->GetDims()(0); ++x ) {
-                index << x,y,z;
+    for (int z = 0; z < this->GetDims()(2); ++z) {
+      for (int x = 0; x < this->GetDims()(0); ++x) {
+        index << x, y, z;
        o << m_Data[Map(index)].Count << " ";
-            } o << "\n";
-        } o << " --------------------------------------------------- \n";
+      }
+      o << "\n";
+    }
+    o << " --------------------------------------------------- \n";
  }
 }

 ////////////////////////////////////////////////////////////////////////////////

-
-
-
-
-
-
-
-#define _TPL_  template < typename VoxelT , typename AlgorithmT >
-#define _TPLT_ VoxelT,AlgorithmT
-
-
+#define _TPL_ template <typename VoxelT, typename AlgorithmT>
+#define _TPLT_ VoxelT, AlgorithmT

 _TPL_
-VoxImageFilter<_TPLT_>::VoxImageFilter(const Vector3i &size) :
-    m_KernelData(size),
-    t_Algoritm(static_cast<AlgorithmT *>(this))
-{
-
-}
+VoxImageFilter<_TPLT_>::VoxImageFilter(const Vector3i &size)
+    : m_KernelData(size), t_Algoritm(static_cast<AlgorithmT *>(this)) {}

 _TPL_
-void VoxImageFilter<_TPLT_>::Run()
-{
+void VoxImageFilter<_TPLT_>::Run() {
  VoxImage<VoxelT> buffer = *m_Image;
-    #pragma omp parallel for
-    for(int i=0 ; i < m_Image->Data().size() ; ++i)
-        m_Image->operator [](i).Value = this->t_Algoritm->Evaluate(buffer,i);
-    #pragma omp barrier
+#pragma omp parallel for
+  for (int i = 0; i < m_Image->Data().size(); ++i)
+    m_Image->operator[](i).Value = this->t_Algoritm->Evaluate(buffer, i);
+#pragma omp barrier
 }

 _TPL_
-void VoxImageFilter<_TPLT_>::SetKernelOffset()
-{
-    Vector3i id(0,0,0);
-    for( int z=0 ; z < m_KernelData.GetDims()(2); ++z ) {
-        for( int x=0 ; x < m_KernelData.GetDims()(0); ++x ) {
-            for( int y=0 ; y < m_KernelData.GetDims()(1); ++y ) {
-                id << x,y,z;
+void VoxImageFilter<_TPLT_>::SetKernelOffset() {
+  Vector3i id(0, 0, 0);
+  for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
+    for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
+      for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
+        id << x, y, z;
        m_KernelData[id].Count = id.transpose() * m_Image->GetIncrements();
      }
    }
@@ -149,62 +128,58 @@ void VoxImageFilter<_TPLT_>::SetKernelOffset()
 }

 _TPL_
-float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v)
-{
+float VoxImageFilter<_TPLT_>::Distance2(const Vector3i &v) {
  Vector3i tmp = v;
  const Vector3i &dim = this->m_KernelData.GetDims();
  Vector3i center = dim / 2;
  tmp = tmp - center;
  center = center.cwiseProduct(center);
  tmp = tmp.cwiseProduct(tmp);
-    return (float)(tmp.sum()) / (float)( center.sum() + 0.25 *
-                                         (3 - (dim(0) % 2) - (dim(1) % 2) - (dim(2) % 2)));
+  return (float)(tmp.sum()) /
+         (float)(center.sum() +
+                 0.25 * (3 - (dim(0) % 2) - (dim(1) % 2) - (dim(2) % 2)));
 }

-
 _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();
-    //m_KernelData.SetDataOrder(StructuredData::XZY);
+  // m_KernelData.SetDataOrder(StructuredData::XZY);
  Vector3i id;
  int index = 0;
-    for( int y=0 ; y < m_KernelData.GetDims()(1); ++y ) {
-        for( int z=0 ; z < m_KernelData.GetDims()(2); ++z ) {
-            for( int x=0 ; x < m_KernelData.GetDims()(0); ++x ) {
-                id << x,y,z;
+  for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
+    for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
+      for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
+        id << x, y, z;
        m_KernelData[id].Value = numeric[index++];
      }
    }
  }
-    //m_KernelData.SetDataOrder(order);
+  // m_KernelData.SetDataOrder(order);
 }

 _TPL_
-void VoxImageFilter<_TPLT_>::SetKernelSpherical(float(* shape)(float))
-{
+void VoxImageFilter<_TPLT_>::SetKernelSpherical(float (*shape)(float)) {
  Vector3i id;
-    for( int y=0 ; y < m_KernelData.GetDims()(1); ++y ) {
-        for( int z=0 ; z < m_KernelData.GetDims()(2); ++z ) {
-            for( int x=0 ; x < m_KernelData.GetDims()(0); ++x ) {
-                id << x,y,z;
+  for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
+    for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
+      for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
+        id << x, y, z;
        m_KernelData[id].Value = shape(this->Distance2(id));
      }
    }
  }
 }

-
 _TPL_ template <class ShapeT>
-void VoxImageFilter<_TPLT_>::SetKernelSpherical(ShapeT shape)
-{
-    Interface::IsA<ShapeT,Interface::VoxImageFilterShape>();
+void VoxImageFilter<_TPLT_>::SetKernelSpherical(ShapeT shape) {
+  Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
  Vector3i id;
-    for( int y=0 ; y < m_KernelData.GetDims()(1); ++y ) {
-        for( int z=0 ; z < m_KernelData.GetDims()(2); ++z ) {
-            for( int x=0 ; x < m_KernelData.GetDims()(0); ++x ) {
-                id << x,y,z;
+  for (int y = 0; y < m_KernelData.GetDims()(1); ++y) {
+    for (int z = 0; z < m_KernelData.GetDims()(2); ++z) {
+      for (int x = 0; x < m_KernelData.GetDims()(0); ++x) {
+        id << x, y, z;
        m_KernelData[id].Value = shape(this->Distance2(id));
      }
    }
@@ -212,19 +187,19 @@ void VoxImageFilter<_TPLT_>::SetKernelSpherical(ShapeT shape)
 }

 _TPL_
-void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(float (*shape)(const Vector3f &))
-{
+void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(
+    float (*shape)(const Vector3f &)) {
  const Vector3i &dim = m_KernelData.GetDims();
  Vector3i id;
  Vector3f pt;
-    for( int y=0 ; y < dim(1); ++y ) {
-        for( int z=0 ; z < dim(2); ++z ) {
-            for( int x=0 ; x < dim(0); ++x ) {
+  for (int y = 0; y < dim(1); ++y) {
+    for (int z = 0; z < dim(2); ++z) {
+      for (int x = 0; x < dim(0); ++x) {
        // get voxels centroid coords from kernel center //
-                id << x,y,z;
-                pt << id(0) - dim(0)/2 + 0.5 * !(dim(0) % 2),
-                      id(1) - dim(1)/2 + 0.5 * !(dim(1) % 2),
-                      id(2) - dim(2)/2 + 0.5 * !(dim(2) % 2);
+        id << x, y, z;
+        pt << id(0) - dim(0) / 2 + 0.5 * !(dim(0) % 2),
+            id(1) - dim(1) / 2 + 0.5 * !(dim(1) % 2),
+            id(2) - dim(2) / 2 + 0.5 * !(dim(2) % 2);
        // compute function using given shape //
        m_KernelData[id].Value = shape(pt);
      }
@@ -232,21 +207,20 @@ void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(float (*shape)(const Vector
  }
 }

-_TPL_ template < class ShapeT >
-void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(ShapeT shape)
-{
-    Interface::IsA<ShapeT,Interface::VoxImageFilterShape>();
+_TPL_ template <class ShapeT>
+void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(ShapeT shape) {
+  Interface::IsA<ShapeT, Interface::VoxImageFilterShape>();
  const Vector3i &dim = m_KernelData.GetDims();
  Vector3i id;
  Vector3f pt;
-    for( int y=0 ; y < dim(1); ++y ) {
-        for( int z=0 ; z < dim(2); ++z ) {
-            for( int x=0 ; x < dim(0); ++x ) {
+  for (int y = 0; y < dim(1); ++y) {
+    for (int z = 0; z < dim(2); ++z) {
+      for (int x = 0; x < dim(0); ++x) {
        // get voxels centroid coords from kernel center //
-                id << x,y,z;
-                pt << id(0) - dim(0)/2 + 0.5 * !(dim(0) % 2),
-                      id(1) - dim(1)/2 + 0.5 * !(dim(1) % 2),
-                      id(2) - dim(2)/2 + 0.5 * !(dim(2) % 2);
+        id << x, y, z;
+        pt << id(0) - dim(0) / 2 + 0.5 * !(dim(0) % 2),
+            id(1) - dim(1) / 2 + 0.5 * !(dim(1) % 2),
+            id(2) - dim(2) / 2 + 0.5 * !(dim(2) % 2);
        // compute function using given shape //
        m_KernelData[id].Value = shape(pt);
      }
@@ -254,22 +228,17 @@ void VoxImageFilter<_TPLT_>::SetKernelWeightFunction(ShapeT shape)
  }
 }

-
-
-
 _TPL_
-void VoxImageFilter<_TPLT_>::SetImage(Abstract::VoxImage *image)
-{
-    this->m_Image = reinterpret_cast<VoxImage<VoxelT> *> (image);
+void VoxImageFilter<_TPLT_>::SetImage(Abstract::VoxImage *image) {
+  this->m_Image = reinterpret_cast<VoxImage<VoxelT> *>(image);
  this->SetKernelOffset();
 }

-
 _TPL_
-float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer, int index)
-{
-    const Vector<VoxelT> &vbuf = buffer.ConstData();
-    const Vector<VoxelT> &vker = m_KernelData.ConstData();
+float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer,
+                                       int index) {
+  const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+  const DataAllocator<VoxelT> &vker = m_KernelData.ConstData();
  int vox_size = vbuf.size();
  int ker_size = vker.size();
  int pos;
@@ -283,20 +252,9 @@ float VoxImageFilter<_TPLT_>::Convolve(const VoxImage<VoxelT> &buffer, int index
  return conv / ksum;
 }

-
-
 #undef _TPLT_
 #undef _TPL_

-
-
-
-
-
-
-}
-
-
-
+} // namespace uLib

 #endif // VOXIMAGEFILTER_HPP
--- a/src/Math/VoxImageFilter2ndStat.hpp
+++ b/src/Math/VoxImageFilter2ndStat.hpp
@@ -23,14 +23,12 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTER2NDSTAT_HPP
 #define VOXIMAGEFILTER2NDSTAT_HPP

-#include <Math/Dense.h>
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
+#include <Math/Dense.h>

 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER ABTRIM  /////////////////////////////////////////////////
@@ -39,19 +37,16 @@
 namespace uLib {

 template <typename VoxelT>
-class VoxFilterAlgorithm2ndStat :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithm2ndStat<VoxelT> > {
+class VoxFilterAlgorithm2ndStat
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithm2ndStat<VoxelT>> {

 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithm2ndStat<VoxelT> > BaseClass;
-    VoxFilterAlgorithm2ndStat(const Vector3i &size) :
-        BaseClass(size)
-    { }
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithm2ndStat<VoxelT>> BaseClass;
+  VoxFilterAlgorithm2ndStat(const Vector3i &size) : BaseClass(size) {}

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+    const DataAllocator<VoxelT> &vker = this->m_KernelData.ConstData();
    int vox_size = vbuf.size();
    int ker_size = vker.size();
    int pos;
@@ -59,7 +54,8 @@ public:
    // mean //
    float conv = 0, ksum = 0;
    for (int ik = 0; ik < ker_size; ++ik) {
-            pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
+      pos = index + vker[ik].Count -
+            vker[this->m_KernelData.GetCenterData()].Count;
      pos = (pos + vox_size) % vox_size;
      conv += vbuf[pos].Value * vker[ik].Value;
      ksum += vker[ik].Value;
@@ -69,15 +65,14 @@ public:
    // rms //
    conv = 0;
    for (int ik = 0; ik < ker_size; ++ik) {
-            pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
+      pos = index + vker[ik].Count -
+            vker[this->m_KernelData.GetCenterData()].Count;
      pos = (pos + vox_size) % vox_size;
-            conv += pow((vbuf[pos].Value * vker[ik].Value) - mean , 2);
+      conv += pow((vbuf[pos].Value * vker[ik].Value) - mean, 2);
    }
-        return conv / (vker.size() - 1) ;
+    return conv / (vker.size() - 1);
  }
-
-
 };

-}
+} // namespace uLib
 #endif // VOXIMAGEFILTER2NDSTAT_HPP
--- a/src/Math/VoxImageFilterABTrim.hpp
+++ b/src/Math/VoxImageFilterABTrim.hpp
@@ -23,14 +23,12 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTERABTRIM_HPP
 #define VOXIMAGEFILTERABTRIM_HPP

-#include <Math/Dense.h>
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
+#include <Math/Dense.h>

 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER ABTRIM  /////////////////////////////////////////////////
@@ -38,38 +36,125 @@

 namespace uLib {

+#if defined(USE_CUDA) && defined(__CUDACC__)
 template <typename VoxelT>
-class VoxFilterAlgorithmAbtrim :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmAbtrim<VoxelT> > {
+__global__ void ABTrimFilterKernel(const VoxelT *in, VoxelT *out,
+                                   const VoxelT *kernel, int vox_size,
+                                   int ker_size, int center_count, int mAtrim,
+                                   int mBtrim) {
+  int index = blockIdx.x * blockDim.x + threadIdx.x;
+  if (index < vox_size) {
+    // Allocate space for sorting
+    extern __shared__ char shared_mem[];
+    VoxelT *mfh =
+        (VoxelT *)&shared_mem[threadIdx.x * ker_size * sizeof(VoxelT)];

-    struct KernelSortAscending
-    {
-        bool operator()(const VoxelT& e1, const VoxelT& e2)
-        { return e1.Value < e2.Value; }
+    for (int i = 0; i < ker_size; ++i) {
+      mfh[i].Count = i;
+    }
+
+    for (int ik = 0; ik < ker_size; ik++) {
+      int pos = index + kernel[ik].Count - center_count;
+      if (pos < 0) {
+        pos += vox_size * ((-pos / vox_size) + 1);
+      }
+      pos = pos % vox_size;
+      mfh[ik].Value = in[pos].Value;
+    }
+
+    // Simple bubble sort for small arrays
+    for (int i = 0; i < ker_size - 1; i++) {
+      for (int j = 0; j < ker_size - i - 1; j++) {
+        if (mfh[j].Value > mfh[j + 1].Value) {
+          VoxelT temp = mfh[j];
+          mfh[j] = mfh[j + 1];
+          mfh[j + 1] = temp;
+        }
+      }
+    }
+
+    float ker_sum = 0;
+    float fconv = 0;
+    for (int ik = 0; ik < mAtrim; ik++) {
+      ker_sum += kernel[mfh[ik].Count].Value;
+    }
+    for (int ik = mAtrim; ik < ker_size - mBtrim; ik++) {
+      fconv += mfh[ik].Value * kernel[mfh[ik].Count].Value;
+      ker_sum += kernel[mfh[ik].Count].Value;
+    }
+    for (int ik = ker_size - mBtrim; ik < ker_size; ik++) {
+      ker_sum += kernel[mfh[ik].Count].Value;
+    }
+
+    out[index].Value = fconv / ker_sum;
+  }
+}
+#endif
+
+template <typename VoxelT>
+class VoxFilterAlgorithmAbtrim
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmAbtrim<VoxelT>> {
+
+  struct KernelSortAscending {
+    bool operator()(const VoxelT &e1, const VoxelT &e2) {
+      return e1.Value < e2.Value;
+    }
  };

 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmAbtrim<VoxelT> > BaseClass;
-    VoxFilterAlgorithmAbtrim(const Vector3i &size) :
-        BaseClass(size)
-    {
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmAbtrim<VoxelT>> BaseClass;
+  VoxFilterAlgorithmAbtrim(const Vector3i &size) : BaseClass(size) {
    mAtrim = 0;
    mBtrim = 0;
  }

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+#if defined(USE_CUDA) && defined(__CUDACC__)
+  void Run() {
+    if (this->m_Image->Data().GetDevice() == MemoryDevice::VRAM ||
+        this->m_KernelData.Data().GetDevice() == MemoryDevice::VRAM) {
+
+      this->m_Image->Data().MoveToVRAM();
+      this->m_KernelData.Data().MoveToVRAM();
+
+      VoxImage<VoxelT> buffer = *(this->m_Image);
+      buffer.Data().MoveToVRAM();
+
+      int vox_size = buffer.Data().size();
+      int ker_size = this->m_KernelData.Data().size();
+
+      VoxelT *d_img_out = this->m_Image->Data().GetVRAMData();
+      const VoxelT *d_img_in = buffer.Data().GetVRAMData();
+      const VoxelT *d_kernel = this->m_KernelData.Data().GetVRAMData();
+      int center_count =
+          this->m_KernelData[this->m_KernelData.GetCenterData()].Count;
+
+      int threadsPerBlock = 256;
+      int blocksPerGrid = (vox_size + threadsPerBlock - 1) / threadsPerBlock;
+      size_t shared_mem_size = threadsPerBlock * ker_size * sizeof(VoxelT);
+
+      ABTrimFilterKernel<<<blocksPerGrid, threadsPerBlock, shared_mem_size>>>(
+          d_img_in, d_img_out, d_kernel, vox_size, ker_size, center_count,
+          mAtrim, mBtrim);
+      cudaDeviceSynchronize();
+    } else {
+      BaseClass::Run();
+    }
+  }
+#endif
+
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+    const DataAllocator<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
+      mfh[i].Count = i; // index key for ordering function
    for (int ik = 0; ik < ker_size; ik++) {
-            pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
+      pos = index + vker[ik].Count -
+            vker[this->m_KernelData.GetCenterData()].Count;
      pos = (pos + vox_size) % vox_size;
      mfh[ik].Value = vbuf[pos].Value;
    }
@@ -78,63 +163,93 @@ public:
    float ker_sum = 0;
    float fconv = 0;
    for (int ik = 0; ik < mAtrim; ik++)
-            ker_sum += vker[ mfh[ik].Count ].Value;
+      ker_sum += vker[mfh[ik].Count].Value;
    for (int ik = mAtrim; ik < ker_size - mBtrim; ik++) {
-            fconv += mfh[ik].Value * vker[ mfh[ik].Count ].Value; // convloution //
-            ker_sum += vker[ mfh[ik].Count ].Value;
+      fconv += mfh[ik].Value * vker[mfh[ik].Count].Value; // convloution //
+      ker_sum += vker[mfh[ik].Count].Value;
    }
    for (int ik = ker_size - mBtrim; ik < ker_size; ik++)
-            ker_sum += vker[ mfh[ik].Count ].Value;
+      ker_sum += vker[mfh[ik].Count].Value;

    return fconv / ker_sum;
  }

-    inline void SetABTrim(int a, int b) { mAtrim = a; mBtrim = b; }
+  inline void SetABTrim(int a, int b) {
+    mAtrim = a;
+    mBtrim = b;
+  }

 private:
  int mAtrim;
  int mBtrim;
 };

-
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // Roberspierre Filter //

-
-
 template <typename VoxelT>
-class VoxFilterAlgorithmSPR :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmSPR<VoxelT> > {
+class VoxFilterAlgorithmSPR
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmSPR<VoxelT>> {

-    struct KernelSortAscending
-    {
-        bool operator()(const VoxelT& e1, const VoxelT& e2)
-        { return e1.Value < e2.Value; }
+  struct KernelSortAscending {
+    bool operator()(const VoxelT &e1, const VoxelT &e2) {
+      return e1.Value < e2.Value;
+    }
  };

 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmSPR<VoxelT> > BaseClass;
-    VoxFilterAlgorithmSPR(const Vector3i &size) :
-        BaseClass(size)
-    {
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmSPR<VoxelT>> BaseClass;
+  VoxFilterAlgorithmSPR(const Vector3i &size) : BaseClass(size) {
    mAtrim = 0;
    mBtrim = 0;
  }

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+#if defined(USE_CUDA) && defined(__CUDACC__)
+  void Run() {
+    if (this->m_Image->Data().GetDevice() == MemoryDevice::VRAM ||
+        this->m_KernelData.Data().GetDevice() == MemoryDevice::VRAM) {
+
+      this->m_Image->Data().MoveToVRAM();
+      this->m_KernelData.Data().MoveToVRAM();
+
+      VoxImage<VoxelT> buffer = *(this->m_Image);
+      buffer.Data().MoveToVRAM();
+
+      int vox_size = buffer.Data().size();
+      int ker_size = this->m_KernelData.Data().size();
+
+      VoxelT *d_img_out = this->m_Image->Data().GetVRAMData();
+      const VoxelT *d_img_in = buffer.Data().GetVRAMData();
+      const VoxelT *d_kernel = this->m_KernelData.Data().GetVRAMData();
+      int center_count =
+          this->m_KernelData[this->m_KernelData.GetCenterData()].Count;
+
+      int threadsPerBlock = 256;
+      int blocksPerGrid = (vox_size + threadsPerBlock - 1) / threadsPerBlock;
+      size_t shared_mem_size = threadsPerBlock * ker_size * sizeof(VoxelT);
+
+      ABTrimFilterKernel<<<blocksPerGrid, threadsPerBlock, shared_mem_size>>>(
+          d_img_in, d_img_out, d_kernel, vox_size, ker_size, center_count,
+          mAtrim, mBtrim);
+      cudaDeviceSynchronize();
+    } else {
+      BaseClass::Run();
+    }
+  }
+#endif
+
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+    const DataAllocator<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
+      mfh[i].Count = i; // index key for ordering function
    for (int ik = 0; ik < ker_size; ik++) {
      pos = index + vker[ik].Count -
            vker[this->m_KernelData.GetCenterData()].Count;
@@ -144,36 +259,34 @@ public:

    std::sort(mfh.begin(), mfh.end(), KernelSortAscending());
    float spr = vbuf[index].Value;
-        if( (mAtrim > 0 && spr <= mfh[mAtrim-1].Value) ||
-                (mBtrim > 0 && spr >= mfh[ker_size - mBtrim].Value) )
-        {
+    if ((mAtrim > 0 && spr <= mfh[mAtrim - 1].Value) ||
+        (mBtrim > 0 && spr >= mfh[ker_size - mBtrim].Value)) {
      float ker_sum = 0;
      float fconv = 0;
      for (int ik = 0; ik < mAtrim; ik++)
-                ker_sum += vker[ mfh[ik].Count ].Value;
+        ker_sum += vker[mfh[ik].Count].Value;
      for (int ik = mAtrim; ik < ker_size - mBtrim; ik++) {
-                fconv += mfh[ik].Value * vker[ mfh[ik].Count ].Value;
-                ker_sum += vker[ mfh[ik].Count ].Value;
+        fconv += mfh[ik].Value * vker[mfh[ik].Count].Value;
+        ker_sum += vker[mfh[ik].Count].Value;
      }
      for (int ik = ker_size - mBtrim; ik < ker_size; ik++)
-                ker_sum += vker[ mfh[ik].Count ].Value;
+        ker_sum += vker[mfh[ik].Count].Value;

      return fconv / ker_sum;
-        }
-        else
+    } else
      return spr;
  }

-    inline void SetABTrim(int a, int b) { mAtrim = a; mBtrim = b; }
+  inline void SetABTrim(int a, int b) {
+    mAtrim = a;
+    mBtrim = b;
+  }

 private:
  int mAtrim;
  int mBtrim;
 };

-
-
-
-}
+} // namespace uLib

 #endif // VOXIMAGEFILTERABTRIM_HPP
--- a/src/Math/VoxImageFilterBilateral.hpp
+++ b/src/Math/VoxImageFilterBilateral.hpp
@@ -23,14 +23,12 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTERBILATERAL_HPP
 #define VOXIMAGEFILTERBILATERAL_HPP

-#include <Math/Dense.h>
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
+#include <Math/Dense.h>

 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER LINEAR  /////////////////////////////////////////////////
@@ -38,20 +36,18 @@

 namespace uLib {

-
 template <typename VoxelT>
-class VoxFilterAlgorithmBilateral :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateral<VoxelT> > {
+class VoxFilterAlgorithmBilateral
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateral<VoxelT>> {
 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateral<VoxelT> > BaseClass;
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateral<VoxelT>> BaseClass;
  VoxFilterAlgorithmBilateral(const Vector3i &size) : BaseClass(size) {
    m_sigma = 1;
  }

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+    const DataAllocator<VoxelT> &vker = this->m_KernelData.ConstData();
    int vox_size = vbuf.size();
    int ker_size = vker.size();
    int pos;
@@ -59,9 +55,11 @@ public:
    float gamma_smooth;
    for (int ik = 0; ik < ker_size; ++ik) {
      //            if (ik==this->m_KernelData.GetCenterData()) continue;
-            pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
+      pos = index + vker[ik].Count -
+            vker[this->m_KernelData.GetCenterData()].Count;
      pos = (pos + vox_size) % vox_size;
-            gamma_smooth = compute_gauss( fabs(vbuf[index].Value - vbuf[pos].Value) * 1.E6 );
+      gamma_smooth =
+          compute_gauss(fabs(vbuf[index].Value - vbuf[pos].Value) * 1.E6);
      conv += vbuf[pos].Value * vker[ik].Value * gamma_smooth;
      ksum += vker[ik].Value * gamma_smooth;
    }
@@ -72,48 +70,47 @@ public:

 private:
  inline float compute_gauss(const float x) {
-        return 1/(sqrt(2*M_PI)* m_sigma) * exp(-0.5*(x*x)/(m_sigma*m_sigma));
+    return 1 / (sqrt(2 * M_PI) * m_sigma) *
+           exp(-0.5 * (x * x) / (m_sigma * m_sigma));
  }

  Scalarf m_sigma;
 };

-
 template <typename VoxelT>
-class VoxFilterAlgorithmBilateralTrim :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateralTrim<VoxelT> > {
+class VoxFilterAlgorithmBilateralTrim
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateralTrim<VoxelT>> {

-    typedef std::pair<float,float> FPair;
+  typedef std::pair<float, float> FPair;

-    struct KernelSortAscending
-    {
-        bool operator()(const FPair& e1, const FPair& e2)
-        { return e1.second < e2.second; }
+  struct KernelSortAscending {
+    bool operator()(const FPair &e1, const FPair &e2) {
+      return e1.second < e2.second;
+    }
  };

 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateralTrim<VoxelT> > BaseClass;
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmBilateralTrim<VoxelT>>
+      BaseClass;
  VoxFilterAlgorithmBilateralTrim(const Vector3i &size) : BaseClass(size) {
    m_sigma = 1;
    mAtrim = 0;
    mBtrim = 0;
  }

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+    const DataAllocator<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++) {
-            pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
+      pos = index + vker[ik].Count -
+            vker[this->m_KernelData.GetCenterData()].Count;
      pos = (pos + img_size) % img_size;
      mfh[ik].second = vbuf[pos].Value; // image value in second
    }
@@ -124,7 +121,8 @@ public:
    //        for (int ik = 0; ik < mAtrim; ik++)
    //            ksum += mfh[ik].first;
    for (int ik = mAtrim; ik < ker_size - mBtrim; ik++) {
-            gamma_smooth = compute_gauss( fabs(vbuf[index].Value - mfh[ik].second) * 1.E6 );
+      gamma_smooth =
+          compute_gauss(fabs(vbuf[index].Value - mfh[ik].second) * 1.E6);
      conv += mfh[ik].first * mfh[ik].second * gamma_smooth;
      ksum += mfh[ik].first * gamma_smooth;
    }
@@ -135,11 +133,15 @@ public:
  }

  inline void SetIntensitySigma(const float s) { m_sigma = s; }
-    inline void SetABTrim(int a, int b) { mAtrim = a; mBtrim = b; }
+  inline void SetABTrim(int a, int b) {
+    mAtrim = a;
+    mBtrim = b;
+  }

 private:
  inline float compute_gauss(const float x) {
-        return 1/(sqrt(2*M_PI)* m_sigma) * exp(-0.5*(x*x)/(m_sigma*m_sigma));
+    return 1 / (sqrt(2 * M_PI) * m_sigma) *
+           exp(-0.5 * (x * x) / (m_sigma * m_sigma));
  }

  Scalarf m_sigma;
@@ -147,6 +149,6 @@ private:
  int mBtrim;
 };

-}
+} // namespace uLib

 #endif // VOXIMAGEFILTERBILATERAL_HPP
--- a/src/Math/VoxImageFilterCustom.hpp
+++ b/src/Math/VoxImageFilterCustom.hpp
@@ -23,14 +23,14 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTERCUSTOM_HPP
 #define VOXIMAGEFILTERCUSTOM_HPP

-#include <Math/Dense.h>
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
+#include <Math/Dense.h>
+
+#define likely(expr) __builtin_expect(!!(expr), 1)

 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER CUSTOM  /////////////////////////////////////////////////
@@ -39,50 +39,50 @@
 namespace uLib {

 template <typename VoxelT>
-class VoxFilterAlgorithmCustom :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT> > {
+class VoxFilterAlgorithmCustom
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT>> {

+  typedef float (*FunctionPt)(const std::vector<Scalarf> &);

-    typedef float (* FunctionPt)(const Vector<Scalarf> &);
 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT> > BaseClass;
-    VoxFilterAlgorithmCustom(const Vector3i &size) :
-        BaseClass(size), m_CustomEvaluate(NULL)
-    {}
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmCustom<VoxelT>> BaseClass;
+  VoxFilterAlgorithmCustom(const Vector3i &size)
+      : BaseClass(size), m_CustomEvaluate(NULL) {}

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        if(likely(m_CustomEvaluate)) {
-            const Vector<VoxelT> &vbuf = buffer.ConstData();
-            const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    if (likely(m_CustomEvaluate)) {
+      const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+      const DataAllocator<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 = index + vker[ik].Count -
+              vker[this->m_KernelData.GetCenterData()].Count;
        pos = (pos + vox_size) % vox_size;
        mfh[ik] = vbuf[pos].Value * vker[ik].Value;
        ker_sum += vker[ik].Value;
      }

      return this->m_CustomEvaluate(mfh);
+    } else {
+      std::cerr << "Custom evaluate function is NULL \n"
+                << "No operation performed by filter.\n";
+      return 0;
    }
-        else
-            std::cerr << "Custom evaluate function is NULL \n" <<
-                         "No operation performed by filter.\n";
-
  }

-    uLibSetMacro(CustomEvaluate,FunctionPt)
+  inline void SetCustomEvaluate(FunctionPt funPt) {
+    this->m_CustomEvaluate = funPt;
+  }

 private:
  FunctionPt m_CustomEvaluate;
 };

-}
-
+} // namespace uLib

 #endif // VOXIMAGEFILTERCUSTOM_HPP
--- a/src/Math/VoxImageFilterLinear.hpp
+++ b/src/Math/VoxImageFilterLinear.hpp
@@ -23,14 +23,12 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTERLINEAR_HPP
 #define VOXIMAGEFILTERLINEAR_HPP

-#include <Math/Dense.h>
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
+#include <Math/Dense.h>

 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER LINEAR  /////////////////////////////////////////////////
@@ -38,24 +36,78 @@

 namespace uLib {

+#if defined(USE_CUDA) && defined(__CUDACC__)
+template <typename VoxelT>
+__global__ void LinearFilterKernel(const VoxelT *in, VoxelT *out,
+                                   const VoxelT *kernel, int vox_size,
+                                   int ker_size, int center_count) {
+  int index = blockIdx.x * blockDim.x + threadIdx.x;
+  if (index < vox_size) {
+    float conv = 0;
+    float ksum = 0;
+    for (int ik = 0; ik < ker_size; ++ik) {
+      int pos = index + kernel[ik].Count - center_count;
+      if (pos < 0) {
+        pos += vox_size * ((-pos / vox_size) + 1);
+      }
+      pos = pos % vox_size;
+      conv += in[pos].Value * kernel[ik].Value;
+      ksum += kernel[ik].Value;
+    }
+    out[index].Value = conv / ksum;
+  }
+}
+#endif

 template <typename VoxelT>
-class VoxFilterAlgorithmLinear :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmLinear<VoxelT> > {
+class VoxFilterAlgorithmLinear
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmLinear<VoxelT>> {
 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmLinear<VoxelT> > BaseClass;
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmLinear<VoxelT>> BaseClass;
  VoxFilterAlgorithmLinear(const Vector3i &size) : BaseClass(size) {}

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+#if defined(USE_CUDA) && defined(__CUDACC__)
+  void Run() {
+    if (this->m_Image->Data().GetDevice() == MemoryDevice::VRAM ||
+        this->m_KernelData.Data().GetDevice() == MemoryDevice::VRAM) {
+
+      this->m_Image->Data().MoveToVRAM();
+      this->m_KernelData.Data().MoveToVRAM();
+
+      VoxImage<VoxelT> buffer = *(this->m_Image);
+      buffer.Data().MoveToVRAM();
+
+      int vox_size = buffer.Data().size();
+      int ker_size = this->m_KernelData.Data().size();
+
+      VoxelT *d_img_out = this->m_Image->Data().GetVRAMData();
+      const VoxelT *d_img_in = buffer.Data().GetVRAMData();
+      const VoxelT *d_kernel = this->m_KernelData.Data().GetVRAMData();
+      int center_count =
+          this->m_KernelData[this->m_KernelData.GetCenterData()].Count;
+
+      int threadsPerBlock = 256;
+      int blocksPerGrid = (vox_size + threadsPerBlock - 1) / threadsPerBlock;
+
+      LinearFilterKernel<<<blocksPerGrid, threadsPerBlock>>>(
+          d_img_in, d_img_out, d_kernel, vox_size, ker_size, center_count);
+      cudaDeviceSynchronize();
+    } else {
+      BaseClass::Run();
+    }
+  }
+#endif
+
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+    const DataAllocator<VoxelT> &vker = this->m_KernelData.ConstData();
    int vox_size = vbuf.size();
    int ker_size = vker.size();
    int pos;
    float conv = 0, ksum = 0;
    for (int ik = 0; ik < ker_size; ++ik) {
-            pos = index + vker[ik].Count - vker[this->m_KernelData.GetCenterData()].Count;
+      pos = index + vker[ik].Count -
+            vker[this->m_KernelData.GetCenterData()].Count;
      pos = (pos + vox_size) % vox_size;
      conv += vbuf[pos].Value * vker[ik].Value;
      ksum += vker[ik].Value;
@@ -64,6 +116,6 @@ public:
  }
 };

-}
+} // namespace uLib

 #endif // VOXIMAGEFILTERLINEAR_HPP
--- a/src/Math/VoxImageFilterMedian.hpp
+++ b/src/Math/VoxImageFilterMedian.hpp
@@ -23,14 +23,12 @@

 //////////////////////////////////////////////////////////////////////////////*/

-
-
 #ifndef VOXIMAGEFILTERMEDIAN_HPP
 #define VOXIMAGEFILTERMEDIAN_HPP

-#include <Math/Dense.h>
 #include "Math/VoxImage.h"
 #include "VoxImageFilter.h"
+#include <Math/Dense.h>

 ////////////////////////////////////////////////////////////////////////////////
 /////  VOXIMAGE FILTER MEDIAN  /////////////////////////////////////////////////
@@ -39,23 +37,23 @@
 namespace uLib {

 template <typename VoxelT>
-class VoxFilterAlgorithmMedian :
-        public VoxImageFilter<VoxelT, VoxFilterAlgorithmMedian<VoxelT> > {
+class VoxFilterAlgorithmMedian
+    : public VoxImageFilter<VoxelT, VoxFilterAlgorithmMedian<VoxelT>> {
 public:
-    typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmMedian<VoxelT> > BaseClass;
+  typedef VoxImageFilter<VoxelT, VoxFilterAlgorithmMedian<VoxelT>> BaseClass;
  VoxFilterAlgorithmMedian(const Vector3i &size) : BaseClass(size) {}

-    float Evaluate(const VoxImage<VoxelT> &buffer, int index)
-    {
-        const Vector<VoxelT> &vbuf = buffer.ConstData();
-        const Vector<VoxelT> &vker = this->m_KernelData.ConstData();
+  float Evaluate(const VoxImage<VoxelT> &buffer, int index) {
+    const DataAllocator<VoxelT> &vbuf = buffer.ConstData();
+    const DataAllocator<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 = index + vker[ik].Count -
+            vker[this->m_KernelData.GetCenterData()].Count;
      pos = (pos + vox_size) % vox_size;
      mfh[ik] = vbuf[pos].Value * vker[ik].Value;
    }
@@ -63,13 +61,14 @@ public:
    pos = 0;
    // count zeroes in filter kernel to move it out of median //
    for (int i = 0; i < ker_size; ++i)
-            if (vker[i].Value == 0.0) pos++;
+      if (vker[i].Value == 0.0)
+        pos++;
    // median //
    pos += (ker_size - pos) / 2;
    return mfh[pos];
  }
 };

-}
+} // namespace uLib

 #endif // VOXIMAGEFILTERMEDIAN_HPP
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
AndreaRigoni	49cf0aeedd	feat: disable camera spin/inertia by introducing a custom interactor style.r	2026-03-06 17:31:29 +00:00
Andrea Rigoni Garola	40846bba78	Update .gitea/workflows/publish-docs.yaml All checks were successful MkDocs Subpath Deploy / build-and-deploy (push) Successful in 11s Details	2026-03-06 17:52:45 +01:00
Andrea Rigoni Garola	4d681e3373	Update .gitea/workflows/publish-docs.yaml Some checks failed MkDocs Subpath Deploy / build-and-deploy (push) Failing after 12s Details	2026-03-06 17:51:53 +01:00
Andrea Rigoni Garola	3a9efd5598	Update .gitea/workflows/publish-docs.yaml	2026-03-06 17:50:13 +01:00
Andrea Rigoni Garola	fa1930f9d7	Merge pull request 'andrea-dev' (#1 ) from andrea-dev into main Reviewed-on: #1 added CUDA for images and raytracing, added python bindings via pybind11, removed LTK, added documentation	2026-03-06 17:17:52 +01:00
AndreaRigoni	b64afe8773	add documention workflow	2026-03-06 10:45:33 +00:00
AndreaRigoni	f3ebba4931	add thrust	2026-03-06 10:45:14 +00:00
AndreaRigoni	79e1abb2ff	add USE_CUDA env in python_build	2026-03-05 15:17:30 +00:00
AndreaRigoni	554eff9b55	add filters in python bindings	2026-03-05 15:03:19 +00:00
AndreaRigoni	42db99759f	fix py dense	2026-03-05 14:26:05 +00:00
AndreaRigoni	69920acd61	poetry python build	2026-03-05 12:42:14 +00:00
AndreaRigoni	647d0caa1c	feat: Add Python packaging infrastructure and comprehensive bindings for math and vector types.	2026-03-05 11:39:27 +00:00
AndreaRigoni	e69b29a259	add first python bindings	2026-03-05 09:16:15 +00:00
AndreaRigoni	9a59e031ed	feat: Implement a custom MetaAllocator for `uLib::Vector` to enable GPU memory management and integrate CUDA support into the build system.	2026-03-04 20:52:01 +00:00
AndreaRigoni	adedbcc37c	feat: add CUDA raytracing benchmark and refactor `VoxRaytracer::RayData` to use `DataAllocator` for host/device memory management.	2026-03-04 17:47:18 +00:00
AndreaRigoni	eb76521060	add clangd linting fix	2026-03-04 14:37:02 +00:00
AndreaRigoni	b1fb123026	feat: Implement CUDA support for VoxRaytracer, add CUDA tests for voxel image operations, and update CMake to enable CUDA compilation.	2026-03-04 13:59:45 +00:00
AndreaRigoni	52580d8cde	refactor: migrate voxel data storage to DataAllocator for CUDA	2026-02-28 10:05:39 +00:00
AndreaRigoni	07915295cb	feat: fix signaling and implement a ping-pong signal/slot test	2026-02-28 08:58:04 +00:00
AndreaRigoni	d56758d0b3	refactor: Update CMake build system and streamline Core object serialization and property handling.	2026-02-21 16:16:28 +00:00
AndreaRigoni	7ded15d596	chore: remove LTK, MOC, and QVTKViewport2 components.	2026-02-21 15:40:21 +00:00
AndreaRigoni	c04722c2bb	refactor: reformat type introspection code and remove ObjectProps system.	2026-02-21 10:45:25 +00:00
AndreaRigoni	8566ceb662	feat: add `condaenv.yml` for environment setup and update `README.md` with detailed build instructions.	2026-02-20 18:05:40 +00:00
AndreaRigoni	5ae2e106ab	added conanfile	2026-02-20 17:27:30 +00:00
Andrea Rigoni	c526f61f8c	Merge pull request #3 from OpenCMT/andrea-dev fix mismatch Origin - Position	2025-09-25 17:38:45 +02:00
AndreaRigoni	54997fe0ac	fix mismatch Origin - Position	2025-09-25 17:34:23 +02:00
Andrea Rigoni	94bad596ed	Merge pull request #2 from OpenCMT/andrea-dev fix export to Vti	2025-09-23 18:52:54 +02:00
AndreaRigoni	fc909da400	fix export to Vti	2025-09-23 18:21:11 +02:00
Andrea Rigoni	b0240dc807	Merge pull request #1 from OpenCMT/andrea-dev Andrea dev	2025-09-18 13:12:12 +02:00
AndreaRigoni	591cc9d8bc	add version 0.6 - make external build possible	2025-09-05 18:04:54 +02:00
AndreaRigoni	2e401f6fc5	add posibility to compile in build directory	2025-09-04 16:12:38 +02:00
AndreaRigoni	91abd56587	fix Root needs for C++17	2025-09-04 16:11:57 +02:00
AndreaRigoni	01ff8a0a0d	update	2025-09-02 13:01:55 +02:00
AndreaRigoni	b86e27a9c4	add VTK save early	2025-09-02 12:42:46 +02:00
Paolo Andreetto	820730bc84	New root dicts	2023-09-01 14:14:06 +02:00
Paolo Andreetto	06c363ab8c	Workaround for CentOS7	2023-04-04 16:31:30 +02:00
Paolo Andreetto	b7c775ee35	Error handling	2023-02-22 11:20:56 +01:00
Paolo Andreetto	7bc4932d09	Missing component for VTK	2023-02-20 16:10:10 +01:00
Paolo Andreetto	8832f47e75	Fixed build for VTK on alma9	2023-02-20 16:08:30 +01:00
Paolo Andreetto	043a44150c	New writer class for the skin detector	2023-02-17 14:35:31 +01:00
Paolo Andreetto	fce2a39393	Changed version	2023-01-17 10:36:34 +01:00
Paolo Andreetto	d223a3a308	Restored classes for Castor	2023-01-17 10:36:05 +01:00
Paolo Andreetto	843a2d69cf	Removed structures for Castor and muBlast	2020-09-29 15:23:08 +02:00
Paolo Andreetto	a60a21bfe4	Massive reorganization of CMake files	2020-06-29 14:44:26 +02:00
Paolo Andreetto	9d899928b8	Bug fixed for MacOD: removed macro	2020-04-28 13:34:07 +02:00
Paolo Andreetto	c9d3eac038	Moved class from mutom-g4-castor	2020-03-16 15:38:11 +01:00
Paolo Andreetto	27dab10434	Changed rpm structure	2020-03-13 15:23:18 +01:00
Paolo Andreetto	8666283a8a	Restored Root lib	2020-03-12 11:41:22 +01:00
Paolo Andreetto	89d333632c	Fixed header files	2019-12-19 13:56:09 +00:00
Paolo Andreetto	3236b9e599	New classes for new algorithm	2019-12-19 13:52:32 +00:00
Paolo Andreetto	192529aa78	New classes for absorption	2019-12-19 10:47:28 +01:00
Paolo Andreetto	884f5ca084	Changes for jenkins	2019-12-19 10:29:55 +01:00
Paolo Andreetto	6b43046fb6	Removed Pimpl in Vtk	2019-08-07 10:08:13 +00:00
Paolo Andreetto	621084fbfc	Removed dependencies from Core lib	2019-08-07 09:10:36 +00:00
Paolo Andreetto	38c61a4e9b	Removed uLib::Vector	2019-07-31 09:16:53 +00:00
Paolo Andreetto	52d574e317	Fixed unit tests	2019-07-15 08:28:09 +00:00
Paolo Andreetto	8fe8311483	Cmake property for rpm release number	2019-06-05 13:33:06 +00:00
Paolo Andreetto	d6448ea42f	Re-inserted detector header files	2019-06-05 11:56:19 +00:00
Paolo Andreetto	51ef9d05f0	Fixed dependency in header file	2019-06-04 11:49:15 +00:00
Paolo Andreetto	701d89d030	Removed dependency from ltk	2019-06-04 08:52:05 +00:00
Paolo Andreetto	841091a591	Removed ltk and Detectors from build	2019-06-03 12:15:03 +00:00
Paolo Andreetto	d02a095028	Removed macros.h and pimpl	2019-05-10 13:22:00 +00:00
Paolo Andreetto	c00e4a6382	Fixes for doxygen and unit tests	2019-05-10 09:08:26 +00:00
Paolo Andreetto	f8cb48d051	No static link in lib	2019-03-26 15:36:34 +01:00
Paolo Andreetto	9fa51cdc3b	Target for doxygen	2019-01-23 14:02:13 +01:00
Paolo Andreetto	19865a7c8c	Label for jenkins wn	2019-01-21 14:27:35 +01:00
Paolo Andreetto	8d8cc285a5	New workaround for packages	2019-01-21 11:50:27 +01:00
Paolo Andreetto	e8b99dd0d5	CMake module for rpms	2018-12-11 14:19:23 +01:00
Paolo Andreetto	a8672e8620	Skeleton for jenkins file	2018-12-10 14:04:14 +01:00
Andrea Rigoni	b02399cb21	Update README.md	2018-04-19 18:02:24 +02:00
Sara Vanini	e49eb6a484	Create README.md DOI added	2018-04-19 13:53:17 +02:00