--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+
+## ========================
+## == Project definition ==
+## ========================
+
+SET(prj_NAME FrontAlgorithms)
+SET(prj_MAJOR_VERSION 0)
+SET(prj_MINOR_VERSION 1)
+SET(prj_RELEASE_VERSION 0)
+
+## ==========================
+## == Some useful policies ==
+## ==========================
+
+SET(_policies CMP0015 CMP0020 CMP0042)
+FOREACH(_p ${_policies})
+ IF(POLICY ${_p})
+ CMAKE_POLICY(SET ${_p} NEW)
+ ENDIF(POLICY ${_p})
+ENDFOREACH(_p)
+
+## ===========================
+## == Project configuration ==
+## ===========================
+
+PROJECT(${prj_NAME})
+SET(
+ prj_VERSION
+ "${prj_MAJOR_VERSION}.${prj_MINOR_VERSION}.${prj_RELEASE_VERSION}"
+ )
+SET(prj_SHORT_VERSION "${prj_MAJOR_VERSION}")
+
+## =====================================
+## == Functions, packages and options ==
+## =====================================
+
+INCLUDE(cmake/DetectOS.cmake)
+INCLUDE(cmake/Restrictions.cmake)
+INCLUDE(cmake/Functions.cmake)
+INCLUDE(cmake/KitwareTools.cmake)
+INCLUDE(cmake/Options.cmake)
+
+## ===========================
+## == Use all valid subdirs ==
+## ===========================
+
+SET(
+ _include_dirs
+ .
+ lib
+ )
+IF(USE_cpPlugins)
+ LIST(APPEND _include_dirs lib/Instances)
+ENDIF(USE_cpPlugins)
+FOREACH(_dir ${_include_dirs})
+ INCLUDE_DIRECTORIES(
+ ${PROJECT_SOURCE_DIR}/${_dir}
+ ${PROJECT_BINARY_DIR}/${_dir}
+ )
+ENDFOREACH(_dir)
+
+## ========================
+## == Manage source code ==
+## ========================
+
+SUBDIRS(lib)
+IF(USE_cpPlugins)
+ SUBDIRS(plugins)
+ENDIF(USE_cpPlugins)
+
+## eof - $RCSfile$
--- /dev/null
+## =====================
+## == OS-based values ==
+## =====================
+
+SET(prj_NAME_OS "${prj_NAME}_OS_${CMAKE_SYSTEM_NAME}")
+IF("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+ SET(prj_NAME_LIB_PREFIX "lib")
+ SET(prj_NAME_LIB_EXT ".so")
+ SET(prj_NAME_ENV_SEPARATOR ":")
+ SET(prj_NAME_PATH_SEPARATOR "/")
+ELSEIF("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
+ SET(prj_NAME_LIB_PREFIX "lib")
+ SET(prj_NAME_LIB_EXT ".dylib")
+ SET(prj_NAME_ENV_SEPARATOR ":")
+ SET(prj_NAME_PATH_SEPARATOR "/")
+ELSEIF("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
+ SET(prj_NAME_LIB_PREFIX "")
+ SET(prj_NAME_LIB_EXT ".dll")
+ SET(prj_NAME_ENV_SEPARATOR ";")
+ SET(prj_NAME_PATH_SEPARATOR "\\")
+ENDIF("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+
+## eof - $RCSfile$
--- /dev/null
+## -------------------------------------------------------------------------
+FUNCTION(NormPaths output_files)
+SET(_out)
+FOREACH(_f ${ARGN})
+ SET(_d)
+ FILE(TO_CMAKE_PATH ${_f} _d)
+ LIST(APPEND _out ${_d})
+ENDFOREACH(_f)
+SET(${output_files} "${_out}" PARENT_SCOPE)
+ENDFUNCTION()
+
+## -------------------------------------------------------------------------
+FUNCTION(Wrap_Qt_CPP output_files)
+SET(_out)
+FOREACH(_f ${ARGN})
+ IF(EXISTS ${_f})
+ FILE(READ ${_f} _txt)
+ STRING(FIND "${_txt}" "Q_OBJECT" _pos)
+ IF(NOT ${_pos} EQUAL -1)
+ SET(_s)
+ QT4_WRAP_CPP(_s ${_f})
+ SET(_out ${_out} ${_s})
+ ENDIF(NOT ${_pos} EQUAL -1)
+ ENDIF(EXISTS ${_f})
+ENDFOREACH(_f)
+SET(${output_files} "${_out}" PARENT_SCOPE)
+ENDFUNCTION()
+
+## -------------------------------------------------------------------------
+FUNCTION(Wrap_Qt_UI output_files)
+NormPaths(_source_dir ${PROJECT_SOURCE_DIR})
+NormPaths(_binary_dir ${PROJECT_BINARY_DIR})
+SET(_out)
+FOREACH(_f ${ARGN})
+ IF(EXISTS ${_f})
+ GET_FILENAME_COMPONENT(_name ${_f} NAME_WE)
+ GET_FILENAME_COMPONENT(_dir ${_f} DIRECTORY)
+ SET(_base_dir ${_source_dir})
+ STRING(FIND "${_dir}" "${_base_dir}" _pos)
+ IF(${_pos} EQUAL -1)
+ SET(_base_dir ${_binary_dir})
+ STRING(FIND "${_dir}" "${_base_dir}" _pos)
+ ENDIF(${_pos} EQUAL -1)
+ IF(NOT ${_pos} EQUAL -1)
+ STRING(REPLACE "${_base_dir}/" "" _dir ${_dir})
+ SET(_out_f ${_binary_dir}/${_dir}/ui_${_name}.h)
+ LIST(APPEND _out ${_out_f})
+ ADD_CUSTOM_COMMAND(
+ OUTPUT ${_out_f}
+ COMMAND Qt4::uic
+ ARGS -o ${_out_f} ${_f}
+ MAIN_DEPENDENCY ${_f} VERBATIM
+ )
+ ENDIF(NOT ${_pos} EQUAL -1)
+ ENDIF(EXISTS ${_f})
+ENDFOREACH(_f)
+SET(${output_files} "${_out}" PARENT_SCOPE)
+ENDFUNCTION()
+
+## -------------------------------------------------------------------------
+FUNCTION(
+ CreateLib
+ lib_name
+ lib_type
+ lib_source_files
+ lib_header_files
+ lib_qt_ui_files
+ lib_version
+ lib_short_version
+ )
+## -- Configure inputs to be cmake-path compatible
+NormPaths(_sources ${lib_source_files})
+NormPaths(_headers ${lib_header_files})
+NormPaths(_qt_uis ${lib_qt_ui_files})
+
+# -- Prepare Qt4-based code
+IF(Qt4_FOUND)
+ ## -- Guess what headers sould be qt-moc'ed
+ Wrap_Qt_CPP(_qt_moc_sources ${_headers})
+ IF(_qt_moc_sources)
+ SET(_sources ${_sources} ${_qt_moc_sources})
+ ENDIF(_qt_moc_sources)
+
+ ## -- Guess what qt-ui's sould be qt-uic'ed
+ ## -- Wrap qt-ui headers: this is equivalent to QT4_WRAP_UI except to change
+ ## -- the output file
+ Wrap_Qt_UI(_qt_ui_headers ${_qt_uis})
+ IF(_qt_ui_headers)
+ SET(_headers ${_headers} ${_qt_ui_headers})
+ SET(_sources ${_sources} ${_qt_ui_headers})
+ ENDIF(_qt_ui_headers)
+ENDIF(Qt4_FOUND)
+
+## -- Ok, compile library
+IF(_sources)
+ NormPaths(_cur_binary_dir ${CMAKE_CURRENT_BINARY_DIR})
+ ADD_LIBRARY(${lib_name} SHARED ${_sources} ${_headers})
+ SET_TARGET_PROPERTIES(
+ ${lib_name}
+ PROPERTIES
+ VERSION "${lib_version}"
+ SOVERSION "${lib_short_version}"
+ )
+ GENERATE_EXPORT_HEADER(
+ ${lib_name}
+ BASE_NAME ${lib_name}
+ EXPORT_MACRO_NAME ${lib_name}_EXPORT
+ EXPORT_FILE_NAME ${lib_name}_Export.h
+ STATIC_DEFINE ${lib_name}_BUILT_AS_STATIC
+ )
+ SET(${lib_name}_LIB ${lib_name} CACHE INTERNAL "Library ${lib_name}")
+ENDIF(_sources)
+
+ENDFUNCTION()
+
+## -------------------------------------------------------------------------
+FUNCTION(
+ LibFromDir
+ lib_name
+ lib_type
+ lib_source_dir
+ lib_version
+ lib_short_version
+ )
+
+## -- Configure inputs to be cmake-path compatible
+NormPaths(_global_source_dir ${PROJECT_SOURCE_DIR})
+NormPaths(_global_binary_dir ${PROJECT_BINARY_DIR})
+NormPaths(_source_dir ${lib_source_dir})
+STRING(REPLACE "${_global_source_dir}" "" _local_source_dir ${_source_dir})
+SET(_binary_dir ${_global_binary_dir}${_local_source_dir})
+
+## -- Some useful variables
+SET(_sources_extensions .c .cpp .cxx)
+SET(_headers_extensions .h .hpp .hxx)
+SET(_qt_ui_extensions .ui)
+SET(_dirs ${_source_dir} ${_binary_dir})
+SET(_sources)
+SET(_headers)
+SET(_qt_uis)
+
+## -- Glob source code
+FOREACH(_d ${_dirs})
+ FOREACH(_e ${_sources_extensions})
+ FILE(GLOB_RECURSE _f "${_d}/*${_e}")
+ SET(_sources ${_sources} ${_f})
+ ENDFOREACH(_e)
+ FOREACH(_e ${_headers_extensions})
+ FILE(GLOB_RECURSE _f "${_d}/*${_e}")
+ SET(_headers ${_headers} ${_f})
+ ENDFOREACH(_e)
+ FOREACH(_e ${_qt_ui_extensions})
+ FILE(GLOB_RECURSE _f "${_d}/*${_e}")
+ SET(_qt_uis ${_qt_uis} ${_f})
+ ENDFOREACH(_e)
+ENDFOREACH(_d)
+
+## -- Configure some files
+FILE(GLOB_RECURSE _configs "${_source_dir}/*.in")
+FOREACH(_c ${_configs})
+
+ ## -- Build input and output names
+ NormPaths(_input_file ${_c})
+ GET_FILENAME_COMPONENT(_input_name ${_input_file} NAME)
+ GET_FILENAME_COMPONENT(_input_dir ${_input_file} DIRECTORY)
+ STRING(REPLACE ".in" "" _output_name ${_input_name})
+ STRING(REPLACE "${_global_source_dir}" "" _output_dir ${_input_dir})
+ SET(_output_file "${_global_binary_dir}${_output_dir}/${_output_name}")
+
+ ## -- Configure file
+ CONFIGURE_FILE(${_input_file} ${_output_file} @ONLY)
+
+ ## -- Add it to the correct list
+ GET_FILENAME_COMPONENT(_output_ext ${_output_name} EXT)
+ IF(
+ "${_output_ext}" STREQUAL ".h"
+ OR
+ "${_output_ext}" STREQUAL ".hpp"
+ OR
+ "${_output_ext}" STREQUAL ".hxx"
+ )
+ SET(_headers ${_headers})
+ ENDIF()
+ IF(
+ "${_output_ext}" STREQUAL ".c"
+ OR
+ "${_output_ext}" STREQUAL ".cpp"
+ OR
+ "${_output_ext}" STREQUAL ".cxx"
+ )
+ SET(_sources ${_sources})
+ ENDIF()
+ IF("${_output_ext}" STREQUAL ".ui")
+ SET(_qt_uis ${_qt_uis})
+ ENDIF()
+ENDFOREACH(_c)
+IF(ARGN)
+ LIST(APPEND _sources ${ARGN})
+ENDIF(ARGN)
+
+## -- Create library
+CreateLib(
+ ${lib_name} ${lib_type}
+ "${_sources}" "${_headers}" "${_qt_uis}"
+ "${lib_version}" "${lib_short_version}"
+ )
+
+ENDFUNCTION()
+
+## -------------------------------------------------------------------------
+FUNCTION(
+ CompileInstances
+ out_lib_name
+ def_file
+ number_of_files
+ prefix
+ version
+ short_version
+ )
+## -- Configure inputs to be cmake-path compatible
+NormPaths(_def_file ${def_file})
+GET_FILENAME_COMPONENT(_def_name ${_def_file} NAME_WE)
+GET_FILENAME_COMPONENT(_def_dir ${_def_file} DIRECTORY)
+NormPaths(_global_source_dir ${PROJECT_SOURCE_DIR})
+NormPaths(_global_binary_dir ${PROJECT_BINARY_DIR})
+STRING(REPLACE "${_global_source_dir}" "" _out_dir ${_def_dir})
+SET(_out_base "${_global_binary_dir}${_out_dir}")
+SET(_out_header "${_out_base}/${_def_name}.h")
+SET(_lib_name "${prefix}${_def_name}")
+SET(_input_extra_code "${_global_source_dir}${_out_dir}/${_def_name}_extra.cxx")
+
+## -- Infere source code filenames
+MATH(EXPR _last_range "${number_of_files}-1")
+SET(_out_code)
+FOREACH(_n RANGE 0 ${_last_range})
+ LIST(APPEND _out_code ${_out_base}/${_def_name}_${_n}.cxx)
+ENDFOREACH(_n)
+
+## -- Add extra code, if any
+SET(_all_out_code ${_out_code})
+IF(EXISTS ${_input_extra_code})
+ LIST(APPEND _all_out_code ${_input_extra_code})
+ENDIF(EXISTS ${_input_extra_code})
+
+## -- Command to write source code
+ADD_CUSTOM_COMMAND(
+ OUTPUT ${_out_header} ${_out_code}
+ DEPENDS ${cpPlugins_bash_BuildInstances_APP} ${_def_file}
+ COMMAND ${cpPlugins_bash_BuildInstances_APP} ${_def_file} ${_lib_name} ${_out_base}/${_def_name} ${number_of_files}
+ )
+
+## -- Create library
+CreateLib(
+ "${_lib_name}" SHARED
+ "${_all_out_code}" "${_out_header}" ""
+ "${version}" "${short_version}"
+ )
+
+## -- Return value
+SET(${out_lib_name} ${_lib_name} PARENT_SCOPE)
+
+ENDFUNCTION()
+
+## -------------------------------------------------------------------------
+FUNCTION(Wrap_cpPlugins output_lib source_dir version short_version prefix)
+
+## -- Configure inputs to be cmake-path compatible
+NormPaths(_source_dir ${source_dir})
+NormPaths(_global_source_dir ${PROJECT_SOURCE_DIR})
+NormPaths(_global_binary_dir ${PROJECT_BINARY_DIR})
+STRING(REPLACE "${_global_source_dir}" "" _out_dir ${_source_dir})
+SET(_out_dir "${_global_binary_dir}${_out_dir}")
+FILE(MAKE_DIRECTORY ${_out_dir})
+GET_FILENAME_COMPONENT(_lib_name ${_source_dir} NAME_WE)
+SET(_lib_name ${prefix}${_lib_name})
+
+## -- Get source code
+FILE(GLOB_RECURSE _hdr_h "${_source_dir}/*.h")
+FILE(GLOB_RECURSE _hdr_hxx "${_source_dir}/*.hxx")
+FILE(GLOB_RECURSE _hdr_hpp "${_source_dir}/*.hpp")
+FILE(GLOB_RECURSE _src_c "${_source_dir}/*.c")
+FILE(GLOB_RECURSE _src_cxx "${_source_dir}/*.cxx")
+FILE(GLOB_RECURSE _src_cpp "${_source_dir}/*.cpp")
+FILE(GLOB_RECURSE _qt_ui "${_source_dir}/*.ui")
+
+## -- Identify sources to wrap
+SET(_hdr_to_wrap)
+FOREACH(_h ${_hdr_h})
+ FILE(READ ${_h} _txt)
+ STRING(FIND "${_txt}" "cpPluginsObject" _res)
+ IF(NOT ${_res} EQUAL -1)
+ LIST(APPEND _hdr_to_wrap ${_h})
+ ENDIF(NOT ${_res} EQUAL -1)
+ENDFOREACH(_h)
+
+## -- Integrate all source files
+SET(_all_src ${_src_c} ${_src_cpp} ${_src_cxx})
+SET(_all_hdr ${_hdr_h} ${_hdr_hpp} ${_hdr_hxx})
+
+## -- Wrap plugins
+IF(_hdr_to_wrap)
+ SET(_host ${_out_dir}/${_lib_name}_host.cxx)
+ ADD_CUSTOM_COMMAND(
+ OUTPUT ${_host}
+ DEPENDS ${cpPlugins_bash_HostCreator_APP} ${_hdr_to_wrap}
+ COMMAND ${cpPlugins_bash_HostCreator_APP} ${_lib_name} ${_host} ${_hdr_to_wrap}
+ )
+ SET(_all_src ${_all_src} ${_host})
+ENDIF(_hdr_to_wrap)
+
+## -- Ok, build library
+IF(_all_src)
+ CreateLib(
+ ${_lib_name} SHARED
+ "${_all_src}" "${_all_hdr}" "${_qt_ui}"
+ "${version}" "${short_version}"
+ ${ARGN}
+ )
+ SET(${output_lib} ${_lib_name} PARENT_SCOPE)
+ELSE(_all_src)
+ MESSAGE(FATAL_ERROR "No source code found to build \"${_lib_name}\"")
+ENDIF(_all_src)
+ENDFUNCTION()
+
+## -------------------------------------------------------------------------
+FUNCTION(AppFromDir output_app source_dir)
+
+## -- Configure inputs to be cmake-path compatible
+NormPaths(_global_source_dir ${PROJECT_SOURCE_DIR})
+NormPaths(_global_binary_dir ${PROJECT_BINARY_DIR})
+NormPaths(_source_dir ${source_dir})
+STRING(REPLACE "${_global_source_dir}" "" _local_source_dir ${_source_dir})
+SET(_binary_dir ${_global_binary_dir}${_local_source_dir})
+IF(${output_app})
+ SET(_app_name ${${output_app}})
+ELSE(${output_app})
+ GET_FILENAME_COMPONENT(_app_name ${_source_dir} NAME_WE)
+ENDIF(${output_app})
+SET(_app_name_option OFF)
+IF(ARGN)
+ LIST(GET ARGN 0 _app_name_option)
+ENDIF(ARGN)
+OPTION(
+ BUILD_${_app_name}
+ "Build \"${_app_name}\" application"
+ ${_app_name_option}
+ )
+
+## -- Real build commands
+IF(BUILD_${_app_name})
+ ## -- Some useful variables
+ SET(_sources_extensions .c .cpp .cxx)
+ SET(_headers_extensions .h .hpp .hxx)
+ SET(_qt_ui_extensions .ui)
+ SET(_dirs ${_source_dir} ${_binary_dir})
+ SET(_sources)
+ SET(_headers)
+ SET(_qt_uis)
+
+ ## -- Glob source code
+ FOREACH(_d ${_dirs})
+ FOREACH(_e ${_sources_extensions})
+ FILE(GLOB_RECURSE _f "${_d}/*${_e}")
+ SET(_sources ${_sources} ${_f})
+ ENDFOREACH(_e)
+ FOREACH(_e ${_headers_extensions})
+ FILE(GLOB_RECURSE _f "${_d}/*${_e}")
+ SET(_headers ${_headers} ${_f})
+ ENDFOREACH(_e)
+ FOREACH(_e ${_qt_ui_extensions})
+ FILE(GLOB_RECURSE _f "${_d}/*${_e}")
+ SET(_qt_uis ${_qt_uis} ${_f})
+ ENDFOREACH(_e)
+ ENDFOREACH(_d)
+
+ ## -- Configure some files
+ FILE(GLOB_RECURSE _configs "${_source_dir}/*.in")
+ FOREACH(_c ${_configs})
+
+ ## -- Build input and output names
+ NormPaths(_input_file ${_c})
+ GET_FILENAME_COMPONENT(_input_name ${_input_file} NAME)
+ GET_FILENAME_COMPONENT(_input_dir ${_input_file} DIRECTORY)
+ STRING(REPLACE ".in" "" _output_name ${_input_name})
+ STRING(REPLACE "${_global_source_dir}" "" _output_dir ${_input_dir})
+ SET(_output_file "${_global_binary_dir}${_output_dir}/${_output_name}")
+
+ ## -- Configure file
+ CONFIGURE_FILE(${_input_file} ${_output_file} @ONLY)
+
+ ## -- Add it to the correct list
+ GET_FILENAME_COMPONENT(_output_ext ${_output_name} EXT)
+ IF(
+ "${_output_ext}" STREQUAL ".h"
+ OR
+ "${_output_ext}" STREQUAL ".hpp"
+ OR
+ "${_output_ext}" STREQUAL ".hxx"
+ )
+ SET(_headers ${_headers})
+ ENDIF()
+ IF(
+ "${_output_ext}" STREQUAL ".c"
+ OR
+ "${_output_ext}" STREQUAL ".cpp"
+ OR
+ "${_output_ext}" STREQUAL ".cxx"
+ )
+ SET(_sources ${_sources})
+ ENDIF()
+ IF("${_output_ext}" STREQUAL ".ui")
+ SET(_qt_uis ${_qt_uis})
+ ENDIF()
+ ENDFOREACH(_c)
+
+ # -- Prepare Qt4-based code
+ IF(Qt4_FOUND)
+
+ ## -- Guess what headers sould be qt-moc'ed
+ Wrap_Qt_CPP(_qt_moc_sources ${_headers})
+ IF(_qt_moc_sources)
+ SET(_sources ${_sources} ${_qt_moc_sources})
+ ENDIF(_qt_moc_sources)
+ ## -- Guess what qt-ui's sould be qt-uic'ed
+ ## -- Wrap qt-ui headers: this is equivalent to QT4_WRAP_UI except to
+ ## -- change the output file
+ Wrap_Qt_UI(_qt_ui_headers ${_qt_uis})
+ IF(_qt_ui_headers)
+ SET(_headers ${_headers} ${_qt_ui_headers})
+ SET(_sources ${_sources} ${_qt_ui_headers})
+ ENDIF(_qt_ui_headers)
+ ENDIF(Qt4_FOUND)
+
+ ## -- Ok, compile application
+ IF(_sources)
+ SET(_gui_type "")
+ IF(WIN32)
+ SET(_gui_type WIN32)
+ ENDIF(WIN32)
+ IF(APPLE)
+ SET(_gui_type MACOSX_BUNDLE)
+ ENDIF(APPLE)
+ ADD_EXECUTABLE(${_app_name} ${_gui_type} ${_sources})
+ SET(${output_app} ${_app_name} PARENT_SCOPE)
+ ELSE(_sources)
+ SET(${output_app} "" PARENT_SCOPE)
+ MESSAGE(FATAL_ERROR "No source code found to build \"${_app_name}\"")
+ ENDIF(_sources)
+ENDIF(BUILD_${_app_name})
+
+ENDFUNCTION()
+
+## eof - $RCSfile$
--- /dev/null
+# ======================
+# == Find ITK and VTK ==
+# ======================
+
+FIND_PACKAGE(ITK REQUIRED)
+INCLUDE(${ITK_USE_FILE})
+
+FIND_PACKAGE(VTK REQUIRED)
+INCLUDE(${VTK_USE_FILE})
+
+# ===================================================
+# == Do not use itk-vtk glue --> problems ahead!!! ==
+# ===================================================
+
+IF(ITKVtkGlue_LOADED)
+ MESSAGE(FATAL_ERROR "ITKVtkGlue module is available. Please re-compile your ITK without it. It could lead to nasty compilation problems... Just waiting for Kitware to solve it.")
+ENDIF(ITKVtkGlue_LOADED)
+
+## eof - $RCSfile$
--- /dev/null
+## ===============================
+## == Some configurable options ==
+## ===============================
+
+OPTION(USE_cpPlugins "Build cpPlugins-based code" OFF)
+IF(USE_cpPlugins)
+ FIND_PACKAGE(cpPlugins REQUIRED)
+ IF(USE_QT4)
+ INCLUDE(cmake/Qt4Tools.cmake)
+ ENDIF(USE_QT4)
+ENDIF(USE_cpPlugins)
+
+## eof - $RCSfile$
--- /dev/null
+## ==================================================
+## == Find Qt4 and check if it was well configured ==
+## ==================================================
+
+SET(QT4_FOUND "0")
+IF(USE_QT4)
+ FIND_PACKAGE(Qt4 REQUIRED)
+ INCLUDE(${QT_USE_FILE})
+ SET(QT4_FOUND "1")
+ENDIF(USE_QT4)
+
+## eof - $RCSfile$
--- /dev/null
+## =======================================================================
+## == Force c++11 language version ==
+## == NOTE: It seems that by default on Visual Studio Compiler supports ==
+## == c++11, so it only need to be tested on other OS. ==
+## =======================================================================
+
+IF(NOT MSVC)
+ INCLUDE(CheckCXXCompilerFlag)
+ CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+ IF(COMPILER_SUPPORTS_CXX11)
+ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+ ELSE(COMPILER_SUPPORTS_CXX11)
+ CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
+ IF(COMPILER_SUPPORTS_CXX0X)
+ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+ ELSE(COMPILER_SUPPORTS_CXX0X)
+ MESSAGE(
+ FATAL_ERROR
+ "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support."
+ )
+ ENDIF(COMPILER_SUPPORTS_CXX0X)
+ ENDIF(COMPILER_SUPPORTS_CXX11)
+ENDIF(NOT MSVC)
+
+## ===================================================
+## == Prepare header generator to build shared libs ==
+## ===================================================
+
+INCLUDE(GenerateExportHeader)
+
+## ==================================================
+## == Do not allow to build inside the source tree ==
+## ==================================================
+
+IF(PROJECT_BINARY_DIR STREQUAL ${PROJECT_SOURCE_DIR})
+ MESSAGE(FATAL_ERROR "Building in the source tree is not allowed.")
+ENDIF(PROJECT_BINARY_DIR STREQUAL ${PROJECT_SOURCE_DIR})
+
+## =================================================
+## == Where to put targets (executables and libs) ==
+## =================================================
+
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR})
+SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR})
+MARK_AS_ADVANCED(
+ CMAKE_BACKWARDS_COMPATIBILITY
+ EXECUTABLE_OUTPUT_PATH
+ LIBRARY_OUTPUT_PATH
+ )
+
+## eof - $RCSfile$
--- /dev/null
+
+## =========================================
+## == Manage every directory as a library ==
+## =========================================
+
+LibFromDir(
+ fpa
+ SHARED
+ ${CMAKE_CURRENT_SOURCE_DIR}/fpa
+ "${prj_VERSION}" "${prj_SHORT_VERSION}"
+ )
+
+## ==================================
+## == Compile cpPlugins-based code ==
+## ==================================
+
+IF(USE_cpPlugins)
+
+ ## =======================
+ ## == Compile instances ==
+ ## =======================
+
+ SUBDIRS(Instances)
+
+ ## ===================================
+ ## == Libraries to dynamically load ==
+ ## ===================================
+
+ SET(
+ fpa_DynLibs
+ local@fpa
+ )
+ FOREACH(_lib ${fpa_Instances})
+ LIST(APPEND fpa_DynLibs local@${_lib})
+ ENDFOREACH(_lib)
+ FILE(WRITE ${PROJECT_BINARY_DIR}/cpPlugins_Libraries.config "")
+ FOREACH(_lib ${fpa_DynLibs})
+ FILE(APPEND ${PROJECT_BINARY_DIR}/cpPlugins_Libraries.config "${_lib}\n")
+ ENDFOREACH(_lib)
+
+ENDIF(USE_cpPlugins)
+
+## eof - $RCSfile$
--- /dev/null
+SET(_pfx "")
+SET(_all_instances)
+
+## ===========================
+## == Compile each instance ==
+## ===========================
+FILE(GLOB _instances "${CMAKE_CURRENT_SOURCE_DIR}/*.i")
+
+FOREACH(_instance ${_instances})
+ CompileInstances(
+ _lib_name
+ ${_instance} ${cpPlugins_NUMBER_OF_FILES}
+ "${_pfx}" "${prj_VERSION}" "${prj_SHORT_VERSION}"
+ )
+ LIST(APPEND _all_instances ${_lib_name})
+ENDFOREACH(_instance)
+SET(
+ fpa_Instances ${_all_instances}
+ CACHE INTERNAL "All valid instances." FORCE
+ )
+
+## ====================
+## == Link libraries ==
+## ====================
+
+TARGET_LINK_LIBRARIES(
+ ${_pfx}fpa_MinimumSpanningTree
+ ${ITK_LIBRARIES} ${VTK_LIBRARIES} ${cpPlugins_Instances}
+ )
+
+## eof - $RCSfile$
--- /dev/null
+
+i itkIndex.h
+t fpa/Base/MinimumSpanningTree
+t itkSimpleDataObjectDecorator
+
+c fpa::Base::MinimumSpanningTree< itk::Index< #process_dims# >, #reals#, itk::Functor::IndexLexicographicCompare< #process_dims# > >
+
+** eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__ALGORITHM__H__
+#define __FPA__BASE__ALGORITHM__H__
+
+#include <functional>
+#include <set>
+#include <utility>
+#include <vector>
+#include <fpa/Config.h>
+#include <fpa/Base/Events.h>
+
+namespace fpa
+{
+ namespace Base
+ {
+ /**
+ * Base front propagation algorithm. From a series of start seeds with
+ * costs, a priority queue is filled and emptied updating costs. Each
+ * vertex could be marked as "visited", "in the front", "not yet there"
+ * or "freezed".
+ *
+ * @param _TVertex Vertex type.
+ * @param _TScalar Scalar (real computations) type.
+ * @param _TFilter Base class for this algorithm. It should be any
+ * itk-based filter (itk::ProcessObject).
+ * @param _TVertexCompare Vertex lexicographical compare.
+ *
+ */
+ template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare = std::less< _TVertex > >
+ class Algorithm
+ : public _TFilter
+ {
+ public:
+ typedef Algorithm Self;
+ typedef _TFilter Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Template arguments
+ typedef _TVertex TVertex;
+ typedef _TScalar TScalar;
+ typedef _TFilter TFilter;
+ typedef _TVertexCompare TVertexCompare;
+
+ // Some useful types
+ typedef unsigned long TFrontId;
+
+ // Minigraph to represent collisions
+ typedef std::pair< TVertex, bool > TCollision;
+ typedef std::vector< TCollision > TCollisionsRow;
+ typedef std::vector< TCollisionsRow > TCollisions;
+
+ enum TNodeLabel
+ {
+ FarLabel = 0,
+ FrontLabel,
+ AliveLabel
+ };
+
+ /**
+ * WARNING: std::set< T > objects are immutable
+ */
+ struct TNode
+ {
+ static const TVertexCompare VertexCompare;
+ TVertex Vertex;
+ mutable TVertex Parent;
+ mutable TScalar Result;
+ mutable TFrontId FrontId;
+ mutable TNodeLabel Label;
+ bool operator<( const TNode& other ) const
+ { return( VertexCompare( this->Vertex, other.Vertex ) ); }
+ };
+ typedef std::set< TNode > TNodes;
+ typedef std::vector< TVertex > TVertices;
+
+ public:
+ itkTypeMacro( Algorithm, _TFilter );
+
+ itkBooleanMacro( StopAtOneFront );
+ itkGetConstMacro( StopAtOneFront, bool );
+ itkSetMacro( StopAtOneFront, bool );
+
+ itkBooleanMacro( ThrowEvents );
+ itkGetConstMacro( ThrowEvents, bool );
+ itkSetMacro( ThrowEvents, bool );
+
+ fpa_Base_NewEvent( TStartEvent );
+ fpa_Base_NewEvent( TStartLoopEvent );
+ fpa_Base_NewEvent( TStartBacktrackingEvent );
+ fpa_Base_NewEvent( TEndEvent );
+ fpa_Base_NewEvent( TEndLoopEvent );
+ fpa_Base_NewEvent( TEndBacktrackingEvent );
+ fpa_Base_NewEventWithVertex( TCollisionEvent, TVertex );
+ fpa_Base_NewEventWithVertex( TAliveEvent, TVertex );
+ fpa_Base_NewEventWithVertex( TFrontEvent, TVertex );
+ fpa_Base_NewEventWithVertex( TFreezeEvent, TVertex );
+ fpa_Base_NewEventWithVertex( TBacktrackingEvent, TVertex );
+
+ public:
+ virtual void InvokeEvent( const itk::EventObject& e );
+ virtual void InvokeEvent( const itk::EventObject& e ) const;
+
+ unsigned long GetNumberOfSeeds( ) const;
+ void AddSeed( const TVertex& s, const TScalar& v = TScalar( 0 ) );
+ void AddSeed( const TNode& n );
+ void RemoveSeed( const TVertex& s );
+ void RemoveAllSeeds( );
+
+ protected:
+ // Methods to extend itk-based architecture
+ Algorithm( );
+ virtual ~Algorithm( );
+ virtual void GenerateData( ) fpa_OVERRIDE;
+
+ // Front propagation generic methods
+ virtual void _Loop( );
+
+ // Front propagation methods to be overloaded
+ virtual void _BeforeGenerateData( );
+ virtual void _AfterGenerateData( );
+ virtual void _BeforeLoop( );
+ virtual void _AfterLoop( );
+
+ virtual void _InitMarks( ) = 0;
+ virtual void _InitResults( ) = 0;
+ virtual void _DeallocateAuxiliary( ) = 0;
+
+ virtual TFrontId _GetMark( const TVertex& v ) = 0;
+ virtual TFrontId _GetMark( const TNode& v );
+
+ virtual void _Visit( const TNode& n ) = 0;
+ virtual bool _NeedToStop( );
+
+ virtual TVertices _GetNeighborhood( const TVertex& v ) const = 0;
+ virtual TVertices _GetNeighborhood( const TNode& n ) const;
+
+ virtual bool _Result( TNode& node, const TNode& parent ) = 0;
+
+ virtual void _QueueClear( ) = 0;
+ virtual void _QueuePush( const TNode& node ) = 0;
+ virtual TNode _QueuePop( ) = 0;
+ virtual bool _IsQueueEmpty( ) const = 0;
+
+ virtual bool _UpdateCollisions( const TVertex& a, const TVertex& b );
+
+ private:
+ // Purposely not implemented
+ Algorithm( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ TNodes m_Seeds;
+ TCollisions m_Collisions;
+ bool m_StopAtOneFront;
+ bool m_ThrowEvents;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Base/Algorithm.hxx>
+#endif
+
+#endif // __FPA__BASE__ALGORITHM__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__ALGORITHM__HXX__
+#define __FPA__BASE__ALGORITHM__HXX__
+
+#include <queue>
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+const _TVertexCompare fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+TNode::VertexCompare = _TVertexCompare( );
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+InvokeEvent( const itk::EventObject& e )
+{
+ if( this->m_ThrowEvents )
+ this->Superclass::InvokeEvent( e );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+InvokeEvent( const itk::EventObject& e ) const
+{
+ if( this->m_ThrowEvents )
+ this->Superclass::InvokeEvent( e );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+unsigned long fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+GetNumberOfSeeds( ) const
+{
+ return( this->m_Seeds.size( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+AddSeed( const TVertex& s, const TScalar& v )
+{
+ TNode n;
+ n.Vertex = s;
+ n.Parent = s;
+ n.Result = v;
+ n.Label = Self::FrontLabel;
+ this->AddSeed( n );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+AddSeed( const TNode& n )
+{
+ this->m_Seeds.insert( n );
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+RemoveSeed( const TVertex& s )
+{
+ TNode n;
+ n.Vertex = s;
+ typename TNodes::iterator i = this->m_Seeds.find( n );
+ if( i != this->m_Seeds.end( ) )
+ {
+ this->m_Seeds.erase( i );
+ this->Modified( );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+RemoveAllSeeds( )
+{
+ this->m_Seeds.clear( );
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+Algorithm( )
+ : Superclass( ),
+ m_StopAtOneFront( false ),
+ m_ThrowEvents( false )
+{
+}
+
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+~Algorithm( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+GenerateData( )
+{
+ this->InvokeEvent( TStartEvent( ) );
+ this->_BeforeGenerateData( );
+
+ unsigned int N = this->m_Seeds.size( );
+ if( N > 0 )
+ {
+ // Enumerate seeds
+ typename TNodes::iterator nIt = this->m_Seeds.begin( );
+ for( unsigned long i = 1; nIt != this->m_Seeds.end( ); ++nIt, ++i )
+ nIt->FrontId = i;
+
+ // Prepare collisions
+ TCollision coll( TVertex( ), false );
+ TCollisionsRow row( N, coll );
+ this->m_Collisions.clear( );
+ this->m_Collisions.resize( N, row );
+
+ // Put seeds on queue
+ this->_QueueClear( );
+ for( nIt = this->m_Seeds.begin( ); nIt != this->m_Seeds.end( ); ++nIt )
+ this->_QueuePush( *nIt );
+
+ // Init marks and results
+ this->_InitMarks( );
+ this->_InitResults( );
+
+ // Main loop
+ this->_BeforeLoop( );
+ this->_Loop( );
+ this->_AfterLoop( );
+
+ // Deallocate any memory
+ this->_DeallocateAuxiliary( );
+
+ } // fi
+
+ this->_AfterGenerateData( );
+ this->InvokeEvent( TEndEvent( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_Loop( )
+{
+ this->InvokeEvent( TStartLoopEvent( ) );
+ this->_BeforeLoop( );
+
+ while( !( this->_IsQueueEmpty( ) ) )
+ {
+ // Extract next candidate
+ TNode node = this->_QueuePop( );
+
+ // Check if it has been visited
+ if( this->_GetMark( node ) > 0 )
+ continue;
+
+ // Mark it as visited
+ this->_Visit( node );
+ this->InvokeEvent( TAliveEvent( node.Vertex, node.FrontId ) );
+
+ // Check if there is an external stop condition
+ if( this->_NeedToStop( ) )
+ {
+ this->_QueueClear( );
+ continue;
+
+ } // fi
+
+ // Get neighborhood
+ TVertices neighborhood = this->_GetNeighborhood( node );
+
+ // Update neighborhood
+ auto neighIt = neighborhood.begin( );
+ bool stop = false;
+ for( ; neighIt != neighborhood.end( ); ++neighIt )
+ {
+ if( this->_GetMark( *neighIt ) == 0 )
+ {
+ TNode neigh;
+ neigh.Vertex = *neighIt;
+ neigh.Parent = node.Vertex;
+ neigh.FrontId = node.FrontId;
+ if( this->_Result( neigh, node ) )
+ {
+ this->_QueuePush( neigh );
+ this->InvokeEvent( TFrontEvent( *neighIt, node.FrontId ) );
+
+ } // fi
+ }
+ else
+ stop |= this->_UpdateCollisions( node.Vertex, *neighIt );
+
+ } // rof
+
+ if( stop )
+ this->_QueueClear( );
+
+ } // elihw
+
+ this->_AfterLoop( );
+ this->InvokeEvent( TEndLoopEvent( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_BeforeGenerateData( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_AfterGenerateData( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_BeforeLoop( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+void fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_AfterLoop( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+typename fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+TFrontId fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_GetMark( const TNode& v )
+{
+ return( this->_GetMark( v.Vertex ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+bool fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_NeedToStop( )
+{
+ return( false );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+typename fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+TVertices fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_GetNeighborhood( const TNode& n ) const
+{
+ return( this->_GetNeighborhood( n.Vertex ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TFilter, class _TVertexCompare >
+bool fpa::Base::
+Algorithm< _TVertex, _TScalar, _TFilter, _TVertexCompare >::
+_UpdateCollisions( const TVertex& a, const TVertex& b )
+{
+ auto ma = this->_GetMark( a );
+ auto mb = this->_GetMark( b );
+ if( ma == mb || ma == 0 || mb == 0 )
+ return( false );
+ ma--;
+ mb--;
+
+ // Mark collision, if it is new
+ bool ret = false;
+ bool exists = this->m_Collisions[ ma ][ mb ].second;
+ exists &= this->m_Collisions[ mb ][ ma ].second;
+ if( !exists )
+ {
+ this->m_Collisions[ ma ][ mb ].first = a;
+ this->m_Collisions[ ma ][ mb ].second = true;
+ this->m_Collisions[ mb ][ ma ].first = b;
+ this->m_Collisions[ mb ][ ma ].second = true;
+
+ // Stop if one front is desired
+ if( this->m_StopAtOneFront )
+ {
+ // Perform a depth-first iteration on front graph
+ unsigned long N = this->GetNumberOfSeeds( );
+ unsigned long count = 0;
+ std::vector< bool > m( N, false );
+ std::queue< unsigned long > q;
+ q.push( 0 );
+ while( !q.empty( ) )
+ {
+ unsigned long f = q.front( );
+ q.pop( );
+
+ if( m[ f ] )
+ continue;
+ m[ f ] = true;
+ count++;
+
+ for( unsigned int n = 0; n < N; ++n )
+ if( this->m_Collisions[ f ][ n ].second && !m[ n ] )
+ q.push( n );
+
+ } // elihw
+ ret = ( count == N );
+ this->InvokeEvent( TCollisionEvent( a, ma + 1 ) );
+ this->InvokeEvent( TCollisionEvent( b, mb + 1 ) );
+
+ } // fi
+
+ } // fi
+ return( ret );
+}
+
+#endif // __FPA__BASE__ALGORITHM__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__DIJKSTRA__H__
+#define __FPA__BASE__DIJKSTRA__H__
+
+#include <vector>
+#include <itkFunctionBase.h>
+#include <fpa/Base/Algorithm.h>
+#include <fpa/Base/MinimumSpanningTree.h>
+
+namespace fpa
+{
+ namespace Base
+ {
+ /**
+ */
+ template< class _TSuperclass >
+ class Dijkstra
+ : public _TSuperclass
+ {
+ public:
+ typedef Dijkstra Self;
+ typedef _TSuperclass Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Template arguments
+ typedef typename Superclass::TVertex TVertex;
+ typedef typename Superclass::TScalar TScalar;
+ typedef typename Superclass::TFilter TFilter;
+ typedef typename Superclass::TVertexCompare TVertexCompare;
+ typedef typename Superclass::TFrontId TFrontId;
+ typedef typename Superclass::TCollision TCollision;
+ typedef typename Superclass::TCollisionsRow TCollisionsRow;
+ typedef typename Superclass::TCollisions TCollisions;
+ typedef typename Superclass::TNodeLabel TNodeLabel;
+ typedef typename Superclass::TNode TNode;
+ typedef typename Superclass::TNodes TNodes;
+ typedef typename Superclass::TVertices TVertices;
+
+ typedef itk::FunctionBase< TScalar, TScalar > TCostConversionFunction;
+
+ typedef
+ fpa::Base::MinimumSpanningTree< TVertex, TScalar, TVertexCompare >
+ TMinimumSpanningTree;
+
+ struct TDijkstraCmp
+ {
+ bool operator()( const TNode& a, const TNode& b )
+ { return( b.Result < a.Result ); }
+ };
+ static const TDijkstraCmp DijkstraCmp;
+
+ public:
+ itkTypeMacro( Dijkstra, Algorithm );
+
+ itkGetObjectMacro( CostConversionFunction, TCostConversionFunction );
+ itkSetObjectMacro( CostConversionFunction, TCostConversionFunction );
+
+ public:
+ TMinimumSpanningTree* GetMinimumSpanningTree( );
+ const TMinimumSpanningTree* GetMinimumSpanningTree( ) const;
+ void GraftMinimumSpanningTree( itk::DataObject* obj );
+
+ protected:
+ // Methods to extend itk-based architecture
+ Dijkstra( );
+ virtual ~Dijkstra( );
+
+ // Front propagation methods to be overloaded
+ virtual void _AfterGenerateData( ) fpa_OVERRIDE;
+ virtual void _Visit( const TNode& n ) fpa_OVERRIDE;
+ virtual bool _Result( TNode& node, const TNode& parent ) fpa_OVERRIDE;
+ virtual void _QueueClear( ) fpa_OVERRIDE;
+ virtual void _QueuePush( const TNode& node ) fpa_OVERRIDE;
+ virtual TNode _QueuePop( ) fpa_OVERRIDE;
+ virtual bool _IsQueueEmpty( ) const fpa_OVERRIDE;
+
+ // Dijkstra methods to be overloaded
+ virtual TScalar _Cost( const TVertex& a, const TVertex& b ) const = 0;
+
+ private:
+ // Purposely not implemented
+ Dijkstra( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ unsigned int m_MSTIdx;
+ std::vector< TNode > m_Queue;
+ typename TCostConversionFunction::Pointer m_CostConversionFunction;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Base/Dijkstra.hxx>
+#endif
+
+#endif // __FPA__BASE__DIJKSTRA__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__DIJKSTRA__HXX__
+#define __FPA__BASE__DIJKSTRA__HXX__
+
+#include <algorithm>
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+const typename fpa::Base::Dijkstra< _TSuperclass >::TDijkstraCmp
+fpa::Base::Dijkstra< _TSuperclass >::DijkstraCmp =
+fpa::Base::Dijkstra< _TSuperclass >::TDijkstraCmp( );
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+typename fpa::Base::Dijkstra< _TSuperclass >::
+TMinimumSpanningTree* fpa::Base::Dijkstra< _TSuperclass >::
+GetMinimumSpanningTree( )
+{
+ return(
+ dynamic_cast< TMinimumSpanningTree* >(
+ this->itk::ProcessObject::GetOutput( this->m_MSTIdx )
+ )
+ );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+const typename fpa::Base::Dijkstra< _TSuperclass >::
+TMinimumSpanningTree* fpa::Base::Dijkstra< _TSuperclass >::
+GetMinimumSpanningTree( ) const
+{
+ return(
+ dynamic_cast< const TMinimumSpanningTree* >(
+ this->itk::ProcessObject::GetOutput( this->m_MSTIdx )
+ )
+ );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+void fpa::Base::Dijkstra< _TSuperclass >::
+GraftMinimumSpanningTree( itk::DataObject* obj )
+{
+ TMinimumSpanningTree* mst = dynamic_cast< TMinimumSpanningTree* >( obj );
+ if( mst != NULL )
+ this->GraftNthOutput( this->m_MSTIdx, mst );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+fpa::Base::Dijkstra< _TSuperclass >::
+Dijkstra( )
+ : Superclass( ),
+ m_CostConversionFunction( NULL )
+{
+ this->m_MSTIdx = this->GetNumberOfRequiredOutputs( );
+ this->SetNumberOfRequiredOutputs( this->m_MSTIdx + 1 );
+ typename TMinimumSpanningTree::Pointer mst = TMinimumSpanningTree::New( );
+ this->itk::ProcessObject::SetNthOutput( this->m_MSTIdx, mst );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+fpa::Base::Dijkstra< _TSuperclass >::
+~Dijkstra( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+void fpa::Base::Dijkstra< _TSuperclass >::
+_AfterGenerateData( )
+{
+ this->Superclass::_AfterGenerateData( );
+ this->GetMinimumSpanningTree( )->SetCollisions( this->m_Collisions );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+void fpa::Base::Dijkstra< _TSuperclass >::
+_Visit( const TNode& n )
+{
+ this->Superclass::_Visit( n );
+ this->GetMinimumSpanningTree( )->SetNode(
+ n.Vertex, n.Parent, n.FrontId, n.Result
+ );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+bool fpa::Base::Dijkstra< _TSuperclass >::
+_Result( TNode& node, const TNode& parent )
+{
+ node.Result = this->_Cost( node.Vertex, parent.Vertex );
+ if( node.Result >= TScalar( 0 ) )
+ {
+ if( this->m_CostConversionFunction.IsNotNull( ) )
+ node.Result = this->m_CostConversionFunction->Evaluate( node.Result );
+ node.Result += parent.Result;
+ return( true );
+ }
+ else
+ return( false );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+void fpa::Base::Dijkstra< _TSuperclass >::
+_QueueClear( )
+{
+ this->m_Queue.clear( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+void fpa::Base::Dijkstra< _TSuperclass >::
+_QueuePush( const TNode& node )
+{
+ this->m_Queue.push_back( node );
+ std::push_heap( this->m_Queue.begin( ), this->m_Queue.end( ), DijkstraCmp );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+typename fpa::Base::Dijkstra< _TSuperclass >::
+TNode fpa::Base::Dijkstra< _TSuperclass >::
+_QueuePop( )
+{
+ std::pop_heap( this->m_Queue.begin( ), this->m_Queue.end( ), DijkstraCmp );
+ TNode n = this->m_Queue.back( );
+ this->m_Queue.pop_back( );
+ return( n );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+bool fpa::Base::Dijkstra< _TSuperclass >::
+_IsQueueEmpty( ) const
+{
+ return( this->m_Queue.size( ) == 0 );
+}
+
+#endif // __FPA__BASE__DIJKSTRA__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__EVENTS__H__
+#define __FPA__BASE__EVENTS__H__
+
+#include <vector>
+#include <itkProcessObject.h>
+
+// -------------------------------------------------------------------------
+#define fpa_Base_NewEvent( name ) \
+ class name \
+ : public BaseEvent \
+ { \
+ public: \
+ name( ) : BaseEvent( ) { } \
+ virtual ~name( ) { } \
+ const char* GetEventName( ) const \
+ { return( "fpa::Base::##name" ); } \
+ bool CheckEvent( const itk::EventObject* e ) const \
+ { return( dynamic_cast< const name* >( e ) != NULL ); } \
+ itk::EventObject* MakeObject( ) const \
+ { return( new name( ) ); } \
+ };
+
+// -------------------------------------------------------------------------
+#define fpa_Base_NewEventWithVertex( name, type ) \
+ class name \
+ : public BaseEventWithVertex< type > \
+ { \
+ public: \
+ name( ) : BaseEventWithVertex< type >( ) { } \
+ name( const type& v, long fid ) \
+ : BaseEventWithVertex< type >( v, fid ) { } \
+ virtual ~name( ) { } \
+ const char* GetEventName( ) const \
+ { return( "fpa::Base::##name" ); } \
+ bool CheckEvent( const itk::EventObject* e ) const \
+ { return( dynamic_cast< const name* >( e ) != NULL ); } \
+ itk::EventObject* MakeObject( ) const \
+ { return( new name( ) ); } \
+ };
+
+namespace fpa
+{
+ namespace Base
+ {
+ /**
+ */
+ class BaseEvent
+ : public itk::AnyEvent
+ {
+ public:
+ BaseEvent( )
+ : itk::AnyEvent( )
+ { }
+ virtual ~BaseEvent( )
+ { }
+ const char* GetEventName( ) const
+ { return( "fpa::Base::BaseEvent" ); }
+ bool CheckEvent( const itk::EventObject* e ) const
+ { return( dynamic_cast< const BaseEvent* >( e ) != NULL ); }
+ itk::EventObject* MakeObject( ) const
+ { return( new BaseEvent( ) ); }
+ };
+
+ /**
+ */
+ template< class V >
+ class BaseEventWithVertex
+ : public BaseEvent
+ {
+ public:
+ BaseEventWithVertex( )
+ : BaseEvent( )
+ { }
+ BaseEventWithVertex( const V& v, long fid )
+ : BaseEvent( ),
+ Vertex( v ),
+ FrontId( fid )
+ { }
+ virtual ~BaseEventWithVertex( )
+ { }
+ const char* GetEventName( ) const
+ { return( "fpa::Base::BaseEventWithVertex" ); }
+ bool CheckEvent( const itk::EventObject* e ) const
+ {
+ return(
+ dynamic_cast< const BaseEventWithVertex< V >* >( e ) != NULL
+ );
+ }
+ itk::EventObject* MakeObject( ) const
+ { return( new BaseEventWithVertex< V >( ) ); }
+
+ public:
+ V Vertex;
+ long FrontId;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#endif // __FPA__BASE__EVENTS__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__FUNCTORS__GAUSSIANCOST__H__
+#define __FPA__BASE__FUNCTORS__GAUSSIANCOST__H__
+
+#include <fpa/Config.h>
+#include <itkFunctionBase.h>
+#include <cpExtensions/Algorithms/IterativeGaussianModelEstimator.h>
+
+namespace fpa
+{
+ namespace Base
+ {
+ namespace Functors
+ {
+ /**
+ */
+ template< class _TResult >
+ class GaussianCost
+ : public itk::FunctionBase< _TResult, _TResult >
+ {
+ public:
+ typedef GaussianCost Self;
+ typedef itk::FunctionBase< _TResult, _TResult > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Template arguments
+ typedef _TResult TResult;
+ typedef
+ cpExtensions::Algorithms::IterativeGaussianModelEstimator< TResult, 1 >
+ TModel;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( GaussianCost, Algorithm );
+
+ itkGetConstMacro( SupportSize, unsigned int );
+ itkGetConstMacro( MinimumCost, _TResult );
+ itkGetObjectMacro( Model, TModel );
+ itkGetConstObjectMacro( Model, TModel );
+ itkSetMacro( SupportSize, unsigned int );
+ itkSetMacro( MinimumCost, _TResult );
+
+ public:
+ virtual _TResult Evaluate( const _TResult& x ) const fpa_OVERRIDE;
+
+ protected:
+ // Methods to extend itk-based architecture
+ GaussianCost( );
+ virtual ~GaussianCost( );
+
+ private:
+ // Purposely not implemented
+ GaussianCost( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ unsigned int m_SupportSize;
+ _TResult m_MinimumCost;
+ typename TModel::Pointer m_Model;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Base/Functors/GaussianCost.hxx>
+#endif // ITK_MANUAL_INSTANTIATION
+
+#endif // __FPA__BASE__FUNCTORS__GAUSSIANCOST__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__FUNCTORS__GAUSSIANCOST__HXX__
+#define __FPA__BASE__FUNCTORS__GAUSSIANCOST__HXX__
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+_TResult fpa::Base::Functors::GaussianCost< _TResult >::
+Evaluate( const _TResult& x ) const
+{
+ _TResult r = _TResult( 0 );
+ if( this->m_Model->GetNumberOfSamples( ) > this->m_SupportSize )
+ {
+ r = this->m_Model->SquaredMahalanobis( x );
+ if( r <= _TResult( 1 ) )
+ this->m_Model->AddSample( x );
+ }
+ else
+ {
+ this->m_Model->AddSample( x );
+ if( this->m_Model->GetNumberOfSamples( ) > 2 )
+ r = this->m_Model->SquaredMahalanobis( x );
+
+ } // fi
+ if( r < this->m_MinimumCost )
+ return( this->m_MinimumCost );
+ else
+ return( r );
+}
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+fpa::Base::Functors::GaussianCost< _TResult >::
+GaussianCost( )
+ : Superclass( ),
+ m_SupportSize( 30 ),
+ m_MinimumCost( _TResult( 1e-10 ) )
+{
+ this->m_Model = TModel::New( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+fpa::Base::Functors::GaussianCost< _TResult >::
+~GaussianCost( )
+{
+}
+
+#endif // __FPA__BASE__FUNCTORS__GAUSSIANCOST__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__FUNCTORS__INVERTCOST__H__
+#define __FPA__BASE__FUNCTORS__INVERTCOST__H__
+
+#include <fpa/Config.h>
+#include <itkFunctionBase.h>
+
+namespace fpa
+{
+ namespace Base
+ {
+ namespace Functors
+ {
+ /**
+ */
+ template< class _TResult >
+ class InvertCost
+ : public itk::FunctionBase< _TResult, _TResult >
+ {
+ public:
+ typedef InvertCost Self;
+ typedef itk::FunctionBase< _TResult, _TResult > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Template arguments
+ typedef _TResult TResult;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( InvertCost, Algorithm );
+
+ public:
+ virtual _TResult Evaluate( const _TResult& x ) const fpa_OVERRIDE;
+
+ protected:
+ // Methods to extend itk-based architecture
+ InvertCost( );
+ virtual ~InvertCost( );
+
+ private:
+ // Purposely not implemented
+ InvertCost( const Self& other );
+ Self& operator=( const Self& other );
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Base/Functors/InvertCost.hxx>
+#endif // ITK_MANUAL_INSTANTIATION
+
+#endif // __FPA__BASE__FUNCTORS__INVERTCOST__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__FUNCTORS__INVERTCOST__HXX__
+#define __FPA__BASE__FUNCTORS__INVERTCOST__HXX__
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+_TResult fpa::Base::Functors::InvertCost< _TResult >::
+Evaluate( const _TResult& x ) const
+{
+ return( _TResult( 1 ) / ( _TResult( 1 ) + x ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+fpa::Base::Functors::InvertCost< _TResult >::
+InvertCost( )
+ : Superclass( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+fpa::Base::Functors::InvertCost< _TResult >::
+~InvertCost( )
+{
+}
+
+#endif // __FPA__BASE__FUNCTORS__INVERTCOST__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__MINIMUMSPANNINGTREE__H__
+#define __FPA__BASE__MINIMUMSPANNINGTREE__H__
+
+#include <functional>
+#include <map>
+#include <utility>
+#include <vector>
+#include <itkSimpleDataObjectDecorator.h>
+
+namespace fpa
+{
+ namespace Base
+ {
+ /**
+ */
+ template< class _TVertex, class _TScalar, class _TVertexCompare = std::less< _TVertex > >
+ class MinimumSpanningTree
+ : public itk::SimpleDataObjectDecorator< std::map< _TVertex, std::pair< _TVertex, std::pair< _TScalar, long > >, _TVertexCompare > >
+ {
+ public:
+ typedef std::pair< _TScalar, long > TData;
+ typedef std::pair< _TVertex, TData > TParent;
+ typedef std::map< _TVertex, TParent, _TVertexCompare > TContainer;
+ typedef itk::SimpleDataObjectDecorator< TContainer > Superclass;
+ typedef MinimumSpanningTree Self;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef _TVertex TVertex;
+ typedef _TScalar TScalar;
+ typedef _TVertexCompare TVertexCompare;
+
+ typedef std::vector< TVertex > TVertices;
+ typedef std::pair< TVertex, bool > TCollision;
+ typedef std::vector< TCollision > TCollisionsRow;
+ typedef std::vector< TCollisionsRow > TCollisions;
+
+ typedef std::multimap< double, _TVertex > TNodeQueue;
+
+ protected:
+ typedef std::vector< unsigned long > _TRow;
+ typedef std::vector< _TRow > _TMatrix;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( MinimumSpanningTree, itk::SimpleDataObjectDecorator );
+
+ itkBooleanMacro( FillNodeQueue );
+
+ itkGetConstReferenceMacro( Collisions, TCollisions );
+ itkGetConstReferenceMacro( NodeQueue, TNodeQueue );
+ itkGetConstMacro( FillNodeQueue, bool );
+
+ itkSetMacro( FillNodeQueue, bool );
+
+ public:
+ void SetCollisions( const TCollisions& collisions );
+ TVertices GetPath( const _TVertex& a ) const;
+ TVertices GetPath( const _TVertex& a, const _TVertex& b ) const;
+
+ virtual void SetNode(
+ const _TVertex& vertex,
+ const _TVertex& parent,
+ const long& fid = -1,
+ const _TScalar& result = _TScalar( 0 )
+ );
+ virtual void Clear( );
+
+ protected:
+ MinimumSpanningTree( );
+ virtual ~MinimumSpanningTree( );
+
+ virtual bool _HasVertex( const _TVertex& a ) const;
+ virtual long _FrontId( const _TVertex& a ) const;
+ virtual void _Path( TVertices& path, const _TVertex& a ) const;
+
+ private:
+ // Purposely not implemented
+ MinimumSpanningTree( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ TCollisions m_Collisions;
+ _TMatrix m_FrontPaths;
+ TNodeQueue m_NodeQueue;
+ bool m_FillNodeQueue;
+
+ static const unsigned long INF_VALUE;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Base/MinimumSpanningTree.hxx>
+#endif
+
+#endif // __FPA__BASE__MINIMUMSPANNINGTREE__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__MINIMUMSPANNINGTREE__HXX__
+#define __FPA__BASE__MINIMUMSPANNINGTREE__HXX__
+
+#include <limits>
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+const unsigned long fpa::Base::
+MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::INF_VALUE =
+ std::numeric_limits< unsigned long >::max( );
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+void fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+SetCollisions( const TCollisions& collisions )
+{
+ // Prepare a front graph
+ this->m_Collisions = collisions;
+ unsigned long nSeeds = this->m_Collisions.size( );
+ _TMatrix dist( nSeeds, _TRow( nSeeds, Self::INF_VALUE ) );
+ this->m_FrontPaths = dist;
+ for( unsigned long i = 0; i < nSeeds; ++i )
+ {
+ for( unsigned long j = 0; j < nSeeds; ++j )
+ {
+ if( this->m_Collisions[ i ][ j ].second )
+ {
+ dist[ i ][ j ] = 1;
+ dist[ j ][ i ] = 1;
+ this->m_FrontPaths[ i ][ j ] = j;
+ this->m_FrontPaths[ j ][ i ] = i;
+
+ } // fi
+
+ } // rof
+ dist[ i ][ i ] = 0;
+ this->m_FrontPaths[ i ][ i ] = i;
+
+ } // rof
+
+ // Use Floyd-Warshall to compute all possible paths between fronts
+ for( unsigned long k = 0; k < nSeeds; ++k )
+ {
+ for( unsigned long i = 0; i < nSeeds; ++i )
+ {
+ for( unsigned long j = 0; j < nSeeds; ++j )
+ {
+ // WARNING: you don't want a numeric overflow!!!
+ unsigned long dik = dist[ i ][ k ];
+ unsigned long dkj = dist[ k ][ j ];
+ unsigned long sum = Self::INF_VALUE;
+ if( dik < Self::INF_VALUE && dkj < Self::INF_VALUE )
+ sum = dik + dkj;
+
+ // Ok, continue Floyd-Warshall
+ if( sum < dist[ i ][ j ] )
+ {
+ dist[ i ][ j ] = sum;
+ this->m_FrontPaths[ i ][ j ] = this->m_FrontPaths[ i ][ k ];
+
+ } // fi
+
+ } // rof
+
+ } // rof
+
+ } // rof
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+typename
+fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+TVertices
+fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+GetPath( const _TVertex& a ) const
+{
+ TVertices path;
+ if( this->_HasVertex( a ) )
+ this->_Path( path, a );
+ return( path );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+typename
+fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+TVertices
+fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+GetPath( const _TVertex& a, const _TVertex& b ) const
+{
+ TVertices path;
+
+ // Check existence
+ if( !this->_HasVertex( a ) || !this->_HasVertex( b ) )
+ return( path );
+
+ // Get front ids
+ long fa = this->_FrontId( a ) - 1;
+ long fb = this->_FrontId( b ) - 1;
+
+ if( fa == fb )
+ {
+ // Get paths
+ TVertices ap, bp;
+ this->_Path( ap, a );
+ this->_Path( bp, b );
+
+ // Ignore common part: find common ancestor
+ auto raIt = ap.rbegin( );
+ auto rbIt = bp.rbegin( );
+ while( *raIt == *rbIt && raIt != ap.rend( ) && rbIt != bp.rend( ) )
+ {
+ ++raIt;
+ ++rbIt;
+
+ } // elihw
+ if( raIt != ap.rbegin( ) ) --raIt;
+ if( rbIt != bp.rbegin( ) ) --rbIt;
+
+ // Add part from a
+ for( auto iaIt = ap.begin( ); iaIt != ap.end( ) && *iaIt != *raIt; ++iaIt )
+ path.push_back( *iaIt );
+
+ // Add part from b
+ for( ; rbIt != bp.rend( ); ++rbIt )
+ path.push_back( *rbIt );
+ }
+ else
+ {
+ // Use this->m_FrontPaths from Floyd-Warshall
+ if( this->m_FrontPaths[ fa ][ fb ] < Self::INF_VALUE )
+ {
+ // Compute front path
+ std::vector< long > fpath;
+ fpath.push_back( fa );
+ while( fa != fb )
+ {
+ fa = this->m_FrontPaths[ fa ][ fb ];
+ fpath.push_back( fa );
+
+ } // elihw
+
+ // Continue only if both fronts are connected
+ unsigned int N = fpath.size( );
+ if( N > 0 )
+ {
+ // First path: from start vertex to first collision
+ path = this->GetPath(
+ a, this->m_Collisions[ fpath[ 0 ] ][ fpath[ 1 ] ].first
+ );
+
+ // Intermediary paths
+ for( unsigned int i = 1; i < N - 1; ++i )
+ {
+ TVertices ipath =
+ this->GetPath(
+ this->m_Collisions[ fpath[ i ] ][ fpath[ i - 1 ] ].first,
+ this->m_Collisions[ fpath[ i ] ][ fpath[ i + 1 ] ].first
+ );
+ path.insert( path.end( ), ipath.begin( ), ipath.end( ) );
+
+ } // rof
+
+ // Final path: from last collision to end point
+ TVertices lpath =
+ this->GetPath(
+ this->m_Collisions[ fpath[ N - 1 ] ][ fpath[ N - 2 ] ].first, b
+ );
+ path.insert( path.end( ), lpath.begin( ), lpath.end( ) );
+
+ // Remove repeated vertices
+ auto p = path.begin( );
+ auto q = p;
+ q++;
+ while( q != path.end( ) )
+ {
+ if( *q == *p )
+ {
+ p = path.erase( p );
+ q = p;
+ }
+ else
+ ++p;
+ ++q;
+
+ } // elihw
+
+ } // fi
+
+ } // fi
+
+ } // fi
+ return( path );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+void fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+SetNode(
+ const _TVertex& vertex, const _TVertex& parent,
+ const long& fid, const _TScalar& result
+ )
+{
+ this->Get( )[ vertex ] = TParent( parent, TData( result, fid ) );
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+void fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+Clear( )
+{
+ this->Get( ).clear( );
+ this->m_NodeQueue.clear( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+MinimumSpanningTree( )
+ : Superclass( ),
+ m_FillNodeQueue( false )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+~MinimumSpanningTree( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+bool fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+_HasVertex( const _TVertex& a ) const
+{
+ return( this->Get( ).find( a ) != this->Get( ).end( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+long fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+_FrontId( const _TVertex& a ) const
+{
+ static const long MAX_ID = std::numeric_limits< long >::max( );
+ auto i = this->Get( ).find( a );
+ if( i != this->Get( ).end( ) )
+ return( i->second.second.second );
+ else
+ return( MAX_ID );
+}
+
+// -------------------------------------------------------------------------
+template< class _TVertex, class _TScalar, class _TVertexCompare >
+void fpa::Base::MinimumSpanningTree< _TVertex, _TScalar, _TVertexCompare >::
+_Path( TVertices& path, const _TVertex& a ) const
+{
+ auto& m = this->Get( );
+ auto it = m.find( a );
+ if( it != m.end( ) )
+ {
+ do
+ {
+ path.push_back( it->first );
+ it = m.find( it->second.first );
+
+ } while( it->first != it->second.first );
+ path.push_back( it->first );
+
+ } // fi
+}
+
+#endif // __FPA__BASE__MINIMUMSPANNINGTREE__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__REGIONGROW__H__
+#define __FPA__BASE__REGIONGROW__H__
+
+#include <deque>
+#include <itkFunctionBase.h>
+#include <fpa/Base/Algorithm.h>
+
+namespace fpa
+{
+ namespace Base
+ {
+ /**
+ */
+ template< class _TSuperclass >
+ class RegionGrow
+ : public _TSuperclass
+ {
+ public:
+ typedef RegionGrow Self;
+ typedef _TSuperclass Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Template arguments
+ typedef typename Superclass::TVertex TVertex;
+ typedef typename Superclass::TScalar TScalar;
+ typedef typename Superclass::TFilter TFilter;
+ typedef typename Superclass::TVertexCompare TVertexCompare;
+ typedef typename Superclass::TFrontId TFrontId;
+ typedef typename Superclass::TCollision TCollision;
+ typedef typename Superclass::TCollisionsRow TCollisionsRow;
+ typedef typename Superclass::TCollisions TCollisions;
+ typedef typename Superclass::TNodeLabel TNodeLabel;
+ typedef typename Superclass::TNode TNode;
+ typedef typename Superclass::TNodes TNodes;
+ typedef typename Superclass::TVertices TVertices;
+
+ typedef itk::FunctionBase< TVertex, bool > TRegionGrowFunction;
+
+ public:
+ itkTypeMacro( RegionGrow, Algorithm );
+
+ itkGetObjectMacro( RegionGrowFunction, TRegionGrowFunction );
+ itkGetConstMacro( InsideValue, TScalar );
+ itkGetConstMacro( OutsideValue, TScalar );
+
+ itkSetObjectMacro( RegionGrowFunction, TRegionGrowFunction );
+ itkSetMacro( InsideValue, TScalar );
+ itkSetMacro( OutsideValue, TScalar );
+
+ protected:
+ // Methods to extend itk-based architecture
+ RegionGrow( );
+ virtual ~RegionGrow( );
+
+ // Front propagation methods to be overloaded
+ virtual bool _Result( TNode& node, const TNode& parent ) fpa_OVERRIDE;
+ virtual void _QueueClear( ) fpa_OVERRIDE;
+ virtual void _QueuePush( const TNode& node ) fpa_OVERRIDE;
+ virtual TNode _QueuePop( ) fpa_OVERRIDE;
+ virtual bool _IsQueueEmpty( ) const fpa_OVERRIDE;
+
+ private:
+ // Purposely not implemented
+ RegionGrow( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ std::deque< TNode > m_Queue;
+ typename TRegionGrowFunction::Pointer m_RegionGrowFunction;
+ TScalar m_InsideValue;
+ TScalar m_OutsideValue;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Base/RegionGrow.hxx>
+#endif
+
+#endif // __FPA__BASE__REGIONGROW__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__BASE__REGIONGROW__HXX__
+#define __FPA__BASE__REGIONGROW__HXX__
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+fpa::Base::RegionGrow< _TSuperclass >::
+RegionGrow( )
+ : Superclass( ),
+ m_RegionGrowFunction( NULL ),
+ m_InsideValue( TScalar( 1 ) ),
+ m_OutsideValue( TScalar( 0 ) )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+fpa::Base::RegionGrow< _TSuperclass >::
+~RegionGrow( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+bool fpa::Base::RegionGrow< _TSuperclass >::
+_Result( TNode& node, const TNode& parent )
+{
+ if( this->m_RegionGrowFunction.IsNotNull( ) )
+ {
+ bool res = this->m_RegionGrowFunction->Evaluate( node.Vertex );
+ node.Result = ( res )? this->m_InsideValue: this->m_OutsideValue;
+ return( res );
+ }
+ else
+ {
+ node.Result = this->m_OutsideValue;
+ return( false );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+void fpa::Base::RegionGrow< _TSuperclass >::
+_QueueClear( )
+{
+ this->m_Queue.clear( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+void fpa::Base::RegionGrow< _TSuperclass >::
+_QueuePush( const TNode& node )
+{
+ this->m_Queue.push_back( node );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+typename fpa::Base::RegionGrow< _TSuperclass >::
+TNode fpa::Base::RegionGrow< _TSuperclass >::
+_QueuePop( )
+{
+ TNode n = this->m_Queue.front( );
+ this->m_Queue.pop_front( );
+ return( n );
+}
+
+// -------------------------------------------------------------------------
+template< class _TSuperclass >
+bool fpa::Base::RegionGrow< _TSuperclass >::
+_IsQueueEmpty( ) const
+{
+ return( this->m_Queue.size( ) == 0 );
+}
+
+#endif // __FPA__BASE__REGIONGROW__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#include <fpa/Config.h>
+#include <string>
+
+// -------------------------------------------------------------------------
+std::string fpa_EXPORT GetVersion( )
+{
+ return( fpa_VERSION );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __fpa__h__
+#define __fpa__h__
+
+#include <fpa_Export.h>
+
+/*
+ * =========================================================================
+ * Version numbers and strings
+ * =========================================================================
+ */
+#define fpa_MAJOR_VERSION @prj_MAJ_VER@
+#define fpa_MINOR_VERSION @prj_MIN_VER@
+#define fpa_RELEASE_VERSION @prj_REL_VER@
+#define fpa_VERSION "@prj_VERSION@"
+#define fpa_SHORT_VERSION "@prj_SHORT_VERSION@"
+
+/*
+ * =========================================================================
+ * Language related macros
+ * =========================================================================
+ */
+
+#if __cplusplus >= 201103L
+# define fpa_OVERRIDE override
+# define fpa_DELETE_FUNCTION =delete
+# define fpa_NULLPTR nullptr
+# define fpa_NOEXCEPT noexcept
+# define fpa_HAS_CXX11_STATIC_ASSERT
+# define fpa_HAS_CXX11_RVREF
+#else
+# define fpa_OVERRIDE
+# define fpa_DELETE_FUNCTION
+# define fpa_NULLPTR NULL
+# define fpa_NOEXCEPT throw()
+#endif
+
+#endif // __fpa__h__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__IMAGE__ALGORITHM__H__
+#define __FPA__IMAGE__ALGORITHM__H__
+
+#include <fpa/Base/Algorithm.h>
+#include <itkImage.h>
+#include <itkImageToImageFilter.h>
+
+namespace fpa
+{
+ namespace Image
+ {
+ /**
+ */
+ template< class _TInputImage, class _TOutputImage >
+ class Algorithm
+ : public fpa::Base::Algorithm< typename _TInputImage::IndexType, typename _TOutputImage::PixelType, itk::ImageToImageFilter< _TInputImage, _TOutputImage >, typename _TInputImage::IndexType::LexicographicCompare >
+ {
+ public:
+ typedef fpa::Base::Algorithm< typename _TInputImage::IndexType, typename _TOutputImage::PixelType, itk::ImageToImageFilter< _TInputImage, _TOutputImage >, typename _TInputImage::IndexType::LexicographicCompare > Superclass;
+ typedef Algorithm Self;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Input types
+ typedef _TInputImage TInputImage;
+ typedef _TOutputImage TOutputImage;
+ itkConceptMacro(
+ ImagesSameDimension,
+ (
+ itk::Concept::
+ SameDimension<
+ TInputImage::ImageDimension,
+ TOutputImage::ImageDimension
+ >
+ )
+ );
+
+ // Template arguments
+ typedef typename Superclass::TVertex TVertex;
+ typedef typename Superclass::TScalar TScalar;
+ typedef typename Superclass::TFilter TFilter;
+ typedef typename Superclass::TVertexCompare TVertexCompare;
+ typedef typename Superclass::TFrontId TFrontId;
+ typedef typename Superclass::TCollision TCollision;
+ typedef typename Superclass::TCollisionsRow TCollisionsRow;
+ typedef typename Superclass::TCollisions TCollisions;
+ typedef typename Superclass::TNodeLabel TNodeLabel;
+ typedef typename Superclass::TNode TNode;
+ typedef typename Superclass::TNodes TNodes;
+ typedef typename Superclass::TVertices TVertices;
+
+ typedef itk::Image< TFrontId, TInputImage::ImageDimension > TMarkImage;
+
+ public:
+ itkTypeMacro( Algorithm, _TFilter );
+
+ itkGetConstMacro( NeighborhoodOrder, unsigned short );
+ itkSetMacro( NeighborhoodOrder, unsigned short );
+
+ protected:
+ // Methods to extend itk-imaged architecture
+ Algorithm( );
+ virtual ~Algorithm( );
+
+ // Front propagation methods to be overloaded
+ virtual void _BeforeGenerateData( ) fpa_OVERRIDE;
+ virtual void _InitMarks( ) fpa_OVERRIDE;
+ virtual void _InitResults( ) fpa_OVERRIDE;
+ virtual void _DeallocateAuxiliary( ) fpa_OVERRIDE;
+ virtual TFrontId _GetMark( const TVertex& v ) fpa_OVERRIDE;
+ virtual void _Visit( const TNode& n ) fpa_OVERRIDE;
+ virtual TVertices _GetNeighborhood(
+ const TVertex& v
+ ) const fpa_OVERRIDE;
+
+ private:
+ // Purposely not implemented
+ Algorithm( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ unsigned short m_NeighborhoodOrder;
+ typename TMarkImage::Pointer m_Marks;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Image/Algorithm.hxx>
+#endif
+
+#endif // __FPA__IMAGE__ALGORITHM__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__IMAGE__ALGORITHM__HXX__
+#define __FPA__IMAGE__ALGORITHM__HXX__
+
+#include <itkConstNeighborhoodIterator.h>
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+Algorithm( )
+ : Superclass( ),
+ m_NeighborhoodOrder( 1 )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+~Algorithm( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+void fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+_BeforeGenerateData( )
+{
+ this->Superclass::_BeforeGenerateData( );
+ this->AllocateOutputs( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+void fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+_InitMarks( )
+{
+ TOutputImage* out = this->GetOutput( );
+ this->m_Marks = TMarkImage::New( );
+ this->m_Marks->CopyInformation( out );
+ this->m_Marks->SetRequestedRegion( out->GetRequestedRegion( ) );
+ this->m_Marks->SetBufferedRegion( out->GetBufferedRegion( ) );
+ this->m_Marks->Allocate( );
+ this->m_Marks->FillBuffer( 0 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+void fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+_InitResults( )
+{
+ this->GetOutput( )->FillBuffer( TScalar( 0 ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+void fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+_DeallocateAuxiliary( )
+{
+ this->m_Marks = NULL;
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+typename fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+TFrontId fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+_GetMark( const TVertex& v )
+{
+ if( this->m_Marks->GetRequestedRegion( ).IsInside( v ) )
+ return( this->m_Marks->GetPixel( v ) );
+ else
+ return( 0 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+void fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+_Visit( const TNode& n )
+{
+ if( this->m_Marks->GetRequestedRegion( ).IsInside( n.Vertex ) )
+ {
+ this->m_Marks->SetPixel( n.Vertex, n.FrontId );
+ this->GetOutput( )->SetPixel( n.Vertex, n.Result );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+typename fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+TVertices fpa::Image::Algorithm< _TInputImage, _TOutputImage >::
+_GetNeighborhood( const TVertex& v ) const
+{
+ TVertices neighs;
+ auto reg = this->GetInput( )->GetRequestedRegion( );
+ if( this->m_NeighborhoodOrder == 1 )
+ {
+ for( unsigned int d = 0; d < _TInputImage::ImageDimension; d++ )
+ {
+ for( int i = -1; i <= 1; i += 2 )
+ {
+ TVertex n = v;
+ n[ d ] += i;
+ if( reg.IsInside( n ) )
+ neighs.push_back( n );
+
+ } // rof
+
+ } // rof
+ }
+ else
+ {
+ typedef itk::ConstNeighborhoodIterator< _TInputImage > _TNeighIt;
+ typename _TInputImage::SizeType nSize;
+ nSize.Fill( 1 );
+
+ _TNeighIt nIt( nSize, this->GetInput( ), reg );
+ nIt.SetLocation( v );
+ for( unsigned int i = 0; i < nIt.Size( ); i++ )
+ {
+ TVertex n = nIt.GetIndex( i );
+ if( n == v )
+ continue;
+ if( reg.IsInside( n ) )
+ neighs.push_back( n );
+
+ } // rof
+
+ } // fi
+ return( neighs );
+}
+
+#endif // __FPA__IMAGE__ALGORITHM__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__IMAGE__DIJKSTRA__H__
+#define __FPA__IMAGE__DIJKSTRA__H__
+
+#include <fpa/Base/Dijkstra.h>
+#include <fpa/Image/Algorithm.h>
+
+namespace fpa
+{
+ namespace Image
+ {
+ /**
+ */
+ template< class _TInputImage, class _TOutputImage = _TInputImage >
+ class Dijkstra
+ : public fpa::Base::Dijkstra< fpa::Image::Algorithm< _TInputImage, _TOutputImage > >
+ {
+ public:
+ typedef fpa::Base::Dijkstra< fpa::Image::Algorithm< _TInputImage, _TOutputImage > > Superclass;
+ typedef Dijkstra Self;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Template arguments
+ typedef typename Superclass::TVertex TVertex;
+ typedef typename Superclass::TScalar TScalar;
+ typedef typename Superclass::TFilter TFilter;
+ typedef typename Superclass::TVertexCompare TVertexCompare;
+ typedef typename Superclass::TFrontId TFrontId;
+ typedef typename Superclass::TCollision TCollision;
+ typedef typename Superclass::TCollisionsRow TCollisionsRow;
+ typedef typename Superclass::TCollisions TCollisions;
+ typedef typename Superclass::TNodeLabel TNodeLabel;
+ typedef typename Superclass::TNode TNode;
+ typedef typename Superclass::TNodes TNodes;
+ typedef typename Superclass::TVertices TVertices;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( Dijkstra, fpa::Base::Dijkstra );
+
+ itkBooleanMacro( UseImageSpacing );
+ itkGetConstMacro( UseImageSpacing, bool );
+ itkSetMacro( UseImageSpacing, bool );
+
+ protected:
+ Dijkstra( );
+ virtual ~Dijkstra( );
+
+ // Dijkstra methods to be overloaded
+ virtual TScalar _Cost(
+ const TVertex& a, const TVertex& b
+ ) const fpa_OVERRIDE;
+
+ private:
+ // Purposely not implemented
+ Dijkstra( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ bool m_UseImageSpacing;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Image/Dijkstra.hxx>
+#endif
+
+#endif // __FPA__IMAGE__DIJKSTRA__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__IMAGE__DIJKSTRA__HXX__
+#define __FPA__IMAGE__DIJKSTRA__HXX__
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+fpa::Image::Dijkstra< _TInputImage, _TOutputImage >::
+Dijkstra( )
+ : Superclass( ),
+ m_UseImageSpacing( false )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+fpa::Image::Dijkstra< _TInputImage, _TOutputImage >::
+~Dijkstra( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+typename fpa::Image::Dijkstra< _TInputImage, _TOutputImage >::
+TScalar fpa::Image::Dijkstra< _TInputImage, _TOutputImage >::
+_Cost( const TVertex& a, const TVertex& b ) const
+{
+ auto input = this->GetInput( );
+ TScalar coeff = TScalar( 1 );
+ if( this->m_UseImageSpacing )
+ {
+ typename _TInputImage::PointType pa, pb;
+ input->TransformIndexToPhysicalPoint( a, pa );
+ input->TransformIndexToPhysicalPoint( b, pb );
+ coeff = TScalar( pa.EuclideanDistanceTo( pb ) );
+
+ } // fi
+ TScalar va = TScalar( input->GetPixel( a ) );
+ return( va * coeff );
+}
+
+#endif // __FPA__IMAGE__DIJKSTRA__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __fpa__Image__MultiplyImageAndDistanceMap__h__
+#define __fpa__Image__MultiplyImageAndDistanceMap__h__
+
+#include <itkImageToImageFilter.h>
+
+namespace fpa
+{
+ namespace Image
+ {
+ /**
+ */
+ template< class _TInput, class _TDistanceMap >
+ class MultiplyImageAndDistanceMap
+ : public itk::ImageToImageFilter< _TInput, _TInput >
+ {
+ public:
+ typedef MultiplyImageAndDistanceMap Self;
+ typedef itk::ImageToImageFilter< _TInput, _TInput > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef _TInput TInput;
+ typedef _TDistanceMap TDistanceMap;
+
+ typedef typename TInput::RegionType TRegion;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( MultiplyImageAndDistanceMap, itkImageToImageFilter );
+
+ public:
+ _TDistanceMap* GetDistanceMap( );
+ const _TDistanceMap* GetDistanceMap( ) const;
+ void SetDistanceMap( _TDistanceMap* dmap );
+
+ protected:
+ MultiplyImageAndDistanceMap( );
+ virtual ~MultiplyImageAndDistanceMap( );
+
+ virtual void ThreadedGenerateData(
+ const TRegion& region,
+ itk::ThreadIdType threadId
+ ) fpa_OVERRIDE;
+
+ private:
+ // Purposely not implemented.
+ MultiplyImageAndDistanceMap( const Self& );
+ void operator=( const Self& );
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Image/MultiplyImageAndDistanceMap.hxx>
+#endif // ITK_MANUAL_INSTANTIATION
+
+#endif // __fpa__Image__MultiplyImageAndDistanceMap__h__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __fpa__Image__MultiplyImageAndDistanceMap__hxx__
+#define __fpa__Image__MultiplyImageAndDistanceMap__hxx__
+
+#include <itkImageRegionConstIteratorWithIndex.h>
+#include <itkImageRegionIteratorWithIndex.h>
+#include <itkProgressReporter.h>
+
+// -------------------------------------------------------------------------
+template< class _TInput, class _TDistanceMap >
+_TDistanceMap*
+fpa::Image::MultiplyImageAndDistanceMap< _TInput, _TDistanceMap >::
+GetDistanceMap( )
+{
+ return(
+ dynamic_cast< _TDistanceMap* >(
+ this->itk::ProcessObject::GetInput( 1 )
+ )
+ );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInput, class _TDistanceMap >
+const _TDistanceMap*
+fpa::Image::MultiplyImageAndDistanceMap< _TInput, _TDistanceMap >::
+GetDistanceMap( ) const
+{
+ return(
+ dynamic_cast< const _TDistanceMap* >(
+ this->itk::ProcessObject::GetInput( 1 )
+ )
+ );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInput, class _TDistanceMap >
+void fpa::Image::MultiplyImageAndDistanceMap< _TInput, _TDistanceMap >::
+SetDistanceMap( _TDistanceMap* dmap )
+{
+ this->itk::ProcessObject::SetNthInput( 1, dmap );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInput, class _TDistanceMap >
+fpa::Image::MultiplyImageAndDistanceMap< _TInput, _TDistanceMap >::
+MultiplyImageAndDistanceMap( )
+ : Superclass( )
+{
+ this->SetNumberOfRequiredInputs( 2 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInput, class _TDistanceMap >
+fpa::Image::MultiplyImageAndDistanceMap< _TInput, _TDistanceMap >::
+~MultiplyImageAndDistanceMap( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TInput, class _TDistanceMap >
+void fpa::Image::MultiplyImageAndDistanceMap< _TInput, _TDistanceMap >::
+ThreadedGenerateData( const TRegion& region, itk::ThreadIdType threadId )
+{
+ typedef typename _TInput::PixelType _TPixel;
+ const typename TRegion::SizeType& regionSize = region.GetSize( );
+ if( regionSize[ 0 ] == 0 )
+ return;
+ const _TInput* input = this->GetInput( );
+ const _TDistanceMap* dmap = this->GetDistanceMap( );
+ _TInput* output = this->GetOutput( );
+ itk::ProgressReporter pr( this, threadId, region.GetNumberOfPixels( ) );
+
+ // Prepare iterators
+ itk::ImageRegionConstIteratorWithIndex< _TInput > iIt( input, region );
+ itk::ImageRegionConstIteratorWithIndex< _TDistanceMap > dIt( dmap, region );
+ itk::ImageRegionIteratorWithIndex< _TInput > oIt( output, region );
+ iIt.GoToBegin( );
+ dIt.GoToBegin( );
+ oIt.GoToBegin( );
+ for(
+ ; !iIt.IsAtEnd( ) && !dIt.IsAtEnd( ) && !oIt.IsAtEnd( );
+ ++iIt, ++dIt, ++oIt
+ )
+ {
+ double d = double( dIt.Get( ) );
+ if( !( d >= double( 0 ) ) )
+ {
+ /* TODO
+ double v = double( iIt.Get( ) );
+ if( v >= 0 )
+ oIt.Set( _TPixel( v / std::fabs( d ) ) );
+ else
+ oIt.Set( _TPixel( v * std::fabs( d ) ) );
+ */
+ oIt.Set( _TPixel( 0 ) );
+ }
+ else
+ oIt.Set( iIt.Get( ) );
+ pr.CompletedPixel( );
+
+ } // rof
+}
+
+#endif // __fpa__Image__MultiplyImageAndDistanceMap__hxx__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__IMAGE__REGIONGROW__H__
+#define __FPA__IMAGE__REGIONGROW__H__
+
+#include <fpa/Base/RegionGrow.h>
+#include <fpa/Image/Algorithm.h>
+
+namespace fpa
+{
+ namespace Image
+ {
+ /**
+ */
+ template< class _TInputImage, class _TOutputImage = _TInputImage >
+ class RegionGrow
+ : public fpa::Base::RegionGrow< fpa::Image::Algorithm< _TInputImage, _TOutputImage > >
+ {
+ public:
+ typedef fpa::Base::RegionGrow< fpa::Image::Algorithm< _TInputImage, _TOutputImage > > Superclass;
+ typedef RegionGrow Self;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( RegionGrow, fpa::Base::RegionGrow );
+
+ protected:
+ RegionGrow( );
+ virtual ~RegionGrow( );
+
+ private:
+ // Purposely not implemented
+ RegionGrow( const Self& other );
+ Self& operator=( const Self& other );
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/Image/RegionGrow.hxx>
+#endif
+
+#endif // __FPA__IMAGE__REGIONGROW__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__IMAGE__REGIONGROW__HXX__
+#define __FPA__IMAGE__REGIONGROW__HXX__
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+fpa::Image::RegionGrow< _TInputImage, _TOutputImage >::
+RegionGrow( )
+ : Superclass( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutputImage >
+fpa::Image::RegionGrow< _TInputImage, _TOutputImage >::
+~RegionGrow( )
+{
+}
+
+#endif // __FPA__IMAGE__REGIONGROW__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__VTK__IMAGE__OBSERVER2D__H__
+#define __FPA__VTK__IMAGE__OBSERVER2D__H__
+
+#include <set>
+#include <itkCommand.h>
+#include <vtkActor.h>
+#include <vtkImageActor.h>
+#include <vtkImageData.h>
+#include <vtkPolyData.h>
+#include <vtkSmartPointer.h>
+
+namespace fpa
+{
+ namespace VTK
+ {
+ namespace Image
+ {
+ /**
+ */
+ template< class _TFilter, class _TRenderWindow >
+ class Observer2D
+ : public itk::Command
+ {
+ public:
+ typedef Observer2D Self;
+ typedef itk::Command Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef _TFilter TFilter;
+ typedef _TRenderWindow TRenderWindow;
+ typedef typename TFilter::TInputImage TImage;
+ typedef typename TFilter::TVertex TVertex;
+
+ typedef std::set< TVertex > TVertices;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( Observer2D, itkCommand );
+
+ itkGetConstMacro( RenderPercentage, double );
+ itkSetMacro( RenderPercentage, double );
+
+ public:
+ void SetRenderWindow( _TRenderWindow* rw );
+ void SetPixel(
+ typename TImage::IndexType idx,
+ unsigned char red,
+ unsigned char green,
+ unsigned char blue,
+ unsigned char alpha
+ );
+ void Render( );
+ void Execute( itk::Object* c, const itk::EventObject& e ) fpa_OVERRIDE
+ { this->Execute( ( const itk::Object* )( c ), e ); }
+ void Execute( const itk::Object* c, const itk::EventObject& e ) fpa_OVERRIDE;
+
+ protected:
+ Observer2D( );
+ virtual ~Observer2D( );
+
+ private:
+ // Purposely not implemented
+ Observer2D( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ vtkSmartPointer< vtkImageData > m_Stencil;
+ vtkSmartPointer< vtkImageActor > m_StencilActor;
+
+ _TRenderWindow* m_RenderWindow;
+ unsigned long m_Count;
+ unsigned long m_RenderCount;
+ double m_RenderPercentage;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/VTK/Image/Observer2D.hxx>
+#endif // ITK_MANUAL_INSTANTIATION
+
+#endif // __FPA__VTK__IMAGE__OBSERVER2D__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__VTK__IMAGE__OBSERVER2D__HXX__
+#define __FPA__VTK__IMAGE__OBSERVER2D__HXX__
+
+#include <vtkCellArray.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkPoints.h>
+#include <vtkPointData.h>
+#include <vtkProperty.h>
+#include <vtkRenderer.h>
+#include <vtkRendererCollection.h>
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+void fpa::VTK::Image::Observer2D< _TFilter, _TRenderWindow >::
+SetRenderWindow( _TRenderWindow* rw )
+{
+ this->m_RenderWindow = rw;
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+void fpa::VTK::Image::Observer2D< _TFilter, _TRenderWindow >::
+SetPixel(
+ typename TImage::IndexType idx,
+ unsigned char red,
+ unsigned char green,
+ unsigned char blue,
+ unsigned char alpha
+ )
+{
+ this->m_Stencil->SetScalarComponentFromDouble
+ ( idx[ 0 ], idx[ 1 ], 0, 0, red );
+ this->m_Stencil->SetScalarComponentFromDouble
+ ( idx[ 0 ], idx[ 1 ], 0, 1, green );
+ this->m_Stencil->SetScalarComponentFromDouble
+ ( idx[ 0 ], idx[ 1 ], 0, 2, blue );
+ this->m_Stencil->SetScalarComponentFromDouble
+ ( idx[ 0 ], idx[ 1 ], 0, 3, alpha );
+ this->m_Stencil->Modified( );
+ this->m_StencilActor->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+void fpa::VTK::Image::Observer2D< _TFilter, _TRenderWindow >::
+Render( )
+{
+ if( this->m_RenderWindow != NULL )
+ this->m_RenderWindow->Render( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+void fpa::VTK::Image::Observer2D< _TFilter, _TRenderWindow >::
+Execute( const itk::Object* c, const itk::EventObject& e )
+{
+ typedef typename _TFilter::TStartEvent _TStartEvent;
+ typedef typename _TFilter::TStartLoopEvent _TStartLoopEvent;
+ typedef typename _TFilter::TEndEvent _TEndEvent;
+ typedef typename _TFilter::TEndLoopEvent _TEndLoopEvent;
+ typedef typename _TFilter::TAliveEvent _TAliveEvent;
+ typedef typename _TFilter::TFrontEvent _TFrontEvent;
+ typedef typename _TFilter::TFreezeEvent _TFreezeEvent;
+
+ typedef typename _TFilter::TStartBacktrackingEvent _TStartBacktrackingEvent;
+ typedef typename _TFilter::TEndBacktrackingEvent _TEndBacktrackingEvent;
+ typedef typename _TFilter::TBacktrackingEvent _TBacktrackingEvent;
+
+ static unsigned char Colors[][4] =
+ {
+ { 0, 0, 127, 127 },
+ { 0, 127, 127, 127 },
+ { 127, 0, 127, 127 },
+ { 127, 127, 0, 127 },
+ { 0, 0, 63, 127 },
+ { 0, 63, 63, 127 },
+ { 63, 0, 63, 127 },
+ { 63, 63, 0, 127 },
+ { 63, 63, 127, 127 },
+ { 63, 127, 127, 127 },
+ { 127, 63, 127, 127 },
+ { 127, 127, 63, 127 },
+ { 127, 127, 63, 127 },
+ { 127, 63, 63, 127 },
+ { 63, 127, 63, 127 },
+ { 63, 63, 127, 127 }
+ };
+
+ auto filter = dynamic_cast< const _TFilter* >( c );
+ if( this->m_RenderWindow == NULL || filter == NULL )
+ return;
+
+ const _TStartEvent* startEvt = dynamic_cast< const _TStartEvent* >( &e );
+ const _TStartBacktrackingEvent* startBackEvt =
+ dynamic_cast< const _TStartBacktrackingEvent* >( &e );
+ if( startEvt != NULL || startBackEvt != NULL )
+ {
+ const TImage* img = filter->GetInput( );
+ unsigned int minD = TImage::ImageDimension;
+ minD = ( minD < 3 )? minD: 3;
+
+ int e[ 6 ] = { 0 };
+ typename TImage::RegionType reg = img->GetRequestedRegion( );
+ for( unsigned int i = 0; i < minD; i++ )
+ {
+ e[ ( i << 1 ) + 0 ] = reg.GetIndex( )[ i ];
+ e[ ( i << 1 ) + 1 ] = reg.GetIndex( )[ i ] + reg.GetSize( )[ i ] - 1;
+
+ } // rof
+
+ typename TImage::SpacingType spac = img->GetSpacing( );
+ double s[ 3 ] = { 1, 1, 1 };
+ for( unsigned int i = 0; i < minD; i++ )
+ s[ i ] = double( spac[ i ] );
+
+ typename TImage::PointType orig = img->GetOrigin( );
+ double o[ 3 ] = { 0 };
+ for( unsigned int i = 0; i < minD; i++ )
+ o[ i ] = double( orig[ i ] );
+
+ this->m_Stencil->SetExtent( e );
+ this->m_Stencil->SetSpacing( s );
+ this->m_Stencil->SetOrigin( o );
+ this->m_Stencil->AllocateScalars( VTK_UNSIGNED_CHAR, 4 );
+ for( unsigned int i = 0; i < 3; i++ )
+ this->m_Stencil->GetPointData( )->
+ GetScalars( )->FillComponent( i, 255 );
+ this->m_Stencil->GetPointData( )->GetScalars( )->FillComponent( 3, 0 );
+
+ this->m_StencilActor->SetInputData( this->m_Stencil );
+ this->m_StencilActor->InterpolateOff( );
+
+ this->m_Count = 0;
+ this->m_RenderCount = reg.GetNumberOfPixels( );
+
+ vtkRenderer* ren =
+ this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
+ ren->AddActor( this->m_StencilActor );
+ return;
+
+ } // fi
+
+ const _TAliveEvent* aliveEvt = dynamic_cast< const _TAliveEvent* >( &e );
+ const _TFrontEvent* frontEvt = dynamic_cast< const _TFrontEvent* >( &e );
+ if( aliveEvt != NULL || frontEvt != NULL )
+ {
+ if( aliveEvt != NULL )
+ this->SetPixel(
+ aliveEvt->Vertex,
+ Colors[ aliveEvt->FrontId ][ 0 ],
+ Colors[ aliveEvt->FrontId ][ 1 ],
+ Colors[ aliveEvt->FrontId ][ 2 ],
+ Colors[ aliveEvt->FrontId ][ 3 ]
+ );
+ else if( frontEvt != NULL )
+ this->SetPixel( frontEvt->Vertex, 255, 0, 0, 255 );
+ this->m_Count++;
+
+ // Render visual debug
+ double per = double( this->m_RenderCount ) * this->m_RenderPercentage;
+ if( double( this->m_Count ) >= per )
+ this->Render( );
+ if( double( this->m_Count ) >= per )
+ this->m_Count = 0;
+
+ return;
+
+ } // fi
+
+ const _TEndEvent* endEvt = dynamic_cast< const _TEndEvent* >( &e );
+ if( endEvt != NULL )
+ {
+ vtkRenderer* ren =
+ this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
+ ren->RemoveActor( this->m_StencilActor );
+ this->Render( );
+ return;
+
+ } // fi
+
+ const _TBacktrackingEvent* backEvt =
+ dynamic_cast< const _TBacktrackingEvent* >( &e );
+ const _TEndBacktrackingEvent* endBackEvt =
+ dynamic_cast< const _TEndBacktrackingEvent* >( &e );
+ if( backEvt != NULL )
+ {
+ this->SetPixel( backEvt->Vertex, 0, 0, 255, 255 );
+ return;
+
+ } // fi
+
+ if( endBackEvt != NULL )
+ {
+ this->m_RenderWindow->Render( );
+ /* TODO: DEBUG
+ std::cout << "Press enter: " << std::ends;
+ int aux;
+ std::cin >> aux;
+ */
+ return;
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+fpa::VTK::Image::Observer2D< _TFilter, _TRenderWindow >::
+Observer2D( )
+ : Superclass( ),
+ m_RenderWindow( NULL ),
+ m_RenderPercentage( double( 0.01 ) )
+{
+ this->m_Stencil = vtkSmartPointer< vtkImageData >::New( );
+ this->m_StencilActor = vtkSmartPointer< vtkImageActor >::New( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+fpa::VTK::Image::Observer2D< _TFilter, _TRenderWindow >::
+~Observer2D( )
+{
+}
+
+#endif // __FPA__VTK__IMAGE__OBSERVER2D__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__VTK__IMAGE__OBSERVER3D__H__
+#define __FPA__VTK__IMAGE__OBSERVER3D__H__
+
+#include <map>
+
+#include <itkCommand.h>
+
+#include <vtkActor.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkSmartPointer.h>
+
+namespace fpa
+{
+ namespace VTK
+ {
+ namespace Image
+ {
+ /**
+ */
+ template< class _TFilter, class _TRenderWindow >
+ class Observer3D
+ : public itk::Command
+ {
+ public:
+ typedef Observer3D Self;
+ typedef itk::Command Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef _TFilter TFilter;
+ typedef _TRenderWindow TRenderWindow;
+ typedef typename TFilter::TInputImage TImage;
+ typedef typename TFilter::TVertex TVertex;
+ typedef typename TFilter::TVertexCompare TVertexCompare;
+
+ typedef std::set< TVertex > TVertices;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( Observer3D, itkCommand );
+
+ itkGetConstMacro( RenderPercentage, double );
+ itkSetMacro( RenderPercentage, double );
+
+ public:
+ void SetRenderWindow( _TRenderWindow* rw );
+ void Render( );
+ void Execute( itk::Object* c, const itk::EventObject& e ) fpa_OVERRIDE
+ { this->Execute( ( const itk::Object* )( c ), e ); }
+ void Execute( const itk::Object* c, const itk::EventObject& e ) fpa_OVERRIDE;
+
+ protected:
+ Observer3D( );
+ virtual ~Observer3D( );
+
+ private:
+ Observer3D( const Self& ); // Not impl.
+ void operator=( const Self& ); // Not impl.
+
+ protected:
+ vtkSmartPointer< vtkPolyData > m_PolyData;
+ vtkSmartPointer< vtkPolyDataMapper > m_PolyDataMapper;
+ vtkSmartPointer< vtkActor > m_PolyDataActor;
+ std::map< TVertex, unsigned long, TVertexCompare > m_PointsToReplace;
+ std::map< TVertex, unsigned long, TVertexCompare > m_PointsInFront;
+
+ _TRenderWindow* m_RenderWindow;
+ unsigned long m_Count;
+ unsigned long m_RenderCount;
+ double m_RenderPercentage;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/VTK/Observer3D.hxx>
+#endif // ITK_MANUAL_INSTANTIATION
+
+#endif // __FPA__VTK__IMAGE__OBSERVER3D__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__VTK__IMAGE__OBSERVER3D__HXX__
+#define __FPA__VTK__IMAGE__OBSERVER3D__HXX__
+
+#include <vtkCellArray.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkPoints.h>
+#include <vtkPointData.h>
+#include <vtkProperty.h>
+#include <vtkRenderer.h>
+#include <vtkRendererCollection.h>
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+void fpa::VTK::Image::Observer3D< _TFilter, _TRenderWindow >::
+SetRenderWindow( _TRenderWindow* rw )
+{
+ this->m_RenderWindow = rw;
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+void fpa::VTK::Image::Observer3D< _TFilter, _TRenderWindow >::
+Render( )
+{
+ if( this->m_RenderWindow != NULL )
+ this->m_RenderWindow->Render( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+void fpa::VTK::Image::Observer3D< _TFilter, _TRenderWindow >::
+Execute( const itk::Object* c, const itk::EventObject& e )
+{
+ typedef typename _TFilter::TStartEvent _TStartEvent;
+ typedef typename _TFilter::TStartLoopEvent _TStartLoopEvent;
+ typedef typename _TFilter::TEndEvent _TEndEvent;
+ typedef typename _TFilter::TEndLoopEvent _TEndLoopEvent;
+ typedef typename _TFilter::TAliveEvent _TAliveEvent;
+ typedef typename _TFilter::TFrontEvent _TFrontEvent;
+ typedef typename _TFilter::TFreezeEvent _TFreezeEvent;
+
+ typedef typename _TFilter::TStartBacktrackingEvent _TStartBacktrackingEvent;
+ typedef typename _TFilter::TEndBacktrackingEvent _TEndBacktrackingEvent;
+ typedef typename _TFilter::TBacktrackingEvent _TBacktrackingEvent;
+
+ static unsigned char Colors[][4] =
+ {
+ { 0, 0, 127, 127 },
+ { 0, 127, 127, 127 },
+ { 127, 0, 127, 127 },
+ { 127, 127, 0, 127 },
+ { 0, 0, 63, 127 },
+ { 0, 63, 63, 127 },
+ { 63, 0, 63, 127 },
+ { 63, 63, 0, 127 },
+ { 63, 63, 127, 127 },
+ { 63, 127, 127, 127 },
+ { 127, 63, 127, 127 },
+ { 127, 127, 63, 127 },
+ { 127, 127, 63, 127 },
+ { 127, 63, 63, 127 },
+ { 63, 127, 63, 127 },
+ { 63, 63, 127, 127 }
+ };
+
+ auto filter = dynamic_cast< const _TFilter* >( c );
+ if( this->m_RenderWindow == NULL || filter == NULL )
+ return;
+ auto image = filter->GetInput( );
+ if( image == NULL )
+ return;
+
+ const _TStartEvent* startEvt = dynamic_cast< const _TStartEvent* >( &e );
+ const _TStartBacktrackingEvent* startBackEvt =
+ dynamic_cast< const _TStartBacktrackingEvent* >( &e );
+ if( startEvt != NULL || startBackEvt != NULL )
+ {
+ this->m_Count = 0;
+ this->m_RenderCount =
+ image->GetLargestPossibleRegion( ).GetNumberOfPixels( );
+ this->m_PointsToReplace.clear( );
+ this->m_PointsInFront.clear( );
+
+ vtkRenderer* ren =
+ this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
+ ren->AddActor( this->m_PolyDataActor );
+ return;
+
+ } // fi
+
+ const _TFrontEvent* frontEvt = dynamic_cast< const _TFrontEvent* >( &e );
+ if( frontEvt != NULL )
+ {
+ typename TImage::PointType pnt;
+ image->TransformIndexToPhysicalPoint( frontEvt->Vertex, pnt );
+ if( this->m_PointsToReplace.empty( ) )
+ {
+ unsigned long nPoints = this->m_PolyData->GetNumberOfPoints( );
+ this->m_PolyData->GetPoints( )->
+ InsertNextPoint( pnt[ 0 ], pnt[ 1 ], pnt[ 2 ] );
+ this->m_PolyData->GetVerts( )->InsertNextCell( 1 );
+ this->m_PolyData->GetVerts( )->InsertCellPoint( nPoints );
+ this->m_PointsInFront[ frontEvt->Vertex ] = nPoints;
+ }
+ else
+ {
+ auto pIt = this->m_PointsToReplace.begin( );
+ this->m_PolyData->GetPoints( )->
+ SetPoint( pIt->second, pnt[ 0 ], pnt[ 1 ], pnt[ 2 ] );
+ this->m_PointsToReplace.erase( pIt );
+
+ } // fi
+ this->m_PolyData->Modified( );
+ this->m_PolyDataMapper->Modified( );
+ this->m_PolyDataActor->Modified( );
+
+ // Render visual debug
+ this->m_Count++;
+ double per = double( this->m_RenderCount ) * this->m_RenderPercentage;
+ if( double( this->m_Count ) >= per )
+ this->Render( );
+ if( double( this->m_Count ) >= per )
+ this->m_Count = 0;
+
+ return;
+
+ } // fi
+
+ const _TAliveEvent* aliveEvt = dynamic_cast< const _TAliveEvent* >( &e );
+ if( aliveEvt != NULL )
+ {
+ auto pIt = this->m_PointsInFront.find( aliveEvt->Vertex );
+ if( pIt != this->m_PointsInFront.end( ) )
+ {
+ this->m_PointsToReplace[ pIt->first ] = pIt->second;
+ this->m_PointsInFront.erase( pIt );
+
+ } // fi
+ return;
+
+ } // fi
+
+ const _TEndEvent* endEvt = dynamic_cast< const _TEndEvent* >( &e );
+ if( endEvt != NULL )
+ {
+ vtkRenderer* ren =
+ this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
+ ren->RemoveActor( this->m_PolyDataActor );
+ this->Render( );
+ return;
+
+ } // fi
+
+ const _TBacktrackingEvent* backEvt =
+ dynamic_cast< const _TBacktrackingEvent* >( &e );
+ const _TEndBacktrackingEvent* endBackEvt =
+ dynamic_cast< const _TEndBacktrackingEvent* >( &e );
+ if( backEvt != NULL )
+ {
+ // TODO:
+ return;
+
+ } // fi
+
+ if( endBackEvt != NULL )
+ {
+ this->m_RenderWindow->Render( );
+
+ /* TODO: DEBUG
+ std::cout << "Press enter: " << std::ends;
+ int aux;
+ std::cin >> aux;
+ */
+ return;
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+fpa::VTK::Image::Observer3D< _TFilter, _TRenderWindow >::
+Observer3D( )
+ : Superclass( ),
+ m_RenderWindow( NULL ),
+ m_RenderPercentage( double( 0.000001 ) )
+{
+ this->m_PolyData = vtkSmartPointer< vtkPolyData >::New( );
+ this->m_PolyDataMapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
+ this->m_PolyDataActor =vtkSmartPointer< vtkActor >::New( );
+
+ vtkSmartPointer< vtkPoints > points =
+ vtkSmartPointer< vtkPoints >::New( );
+ vtkSmartPointer< vtkCellArray > verts =
+ vtkSmartPointer< vtkCellArray >::New( );
+ this->m_PolyData->SetPoints( points );
+ this->m_PolyData->SetVerts( verts );
+ this->m_PolyDataMapper->SetInputData( this->m_PolyData );
+ this->m_PolyDataActor->SetMapper( this->m_PolyDataMapper );
+ this->m_PolyDataActor->GetProperty( )->SetColor( 0, 1, 0 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter, class _TRenderWindow >
+fpa::VTK::Image::Observer3D< _TFilter, _TRenderWindow >::
+~Observer3D( )
+{
+}
+
+#endif // __FPA__VTK__IMAGE__OBSERVER3D__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__VTK__IMAGE__PATHTOPOLYDATAFILTER__H__
+#define __FPA__VTK__IMAGE__PATHTOPOLYDATAFILTER__H__
+
+#include <itkImageBase.h>
+#include <vtkPolyDataAlgorithm.h>
+
+namespace fpa
+{
+ namespace VTK
+ {
+ namespace Image
+ {
+ /**
+ */
+ template< class _TMinimumSpanningTree >
+ class PathToPolyDataFilter
+ : public vtkPolyDataAlgorithm
+ {
+ public:
+ typedef PathToPolyDataFilter Self;
+ typedef _TMinimumSpanningTree TMinimumSpanningTree;
+ typedef typename TMinimumSpanningTree::TVertex TVertex;
+ typedef itk::ImageBase< TVertex::Dimension > TImage;
+
+ public:
+ vtkTypeMacro( PathToPolyDataFilter, vtkPolyDataAlgorithm );
+
+ vtkGetMacro( Seed0, TVertex );
+ vtkGetMacro( Seed1, TVertex );
+
+ vtkSetMacro( Seed0, TVertex );
+ vtkSetMacro( Seed1, TVertex );
+
+ public:
+ static Self* New( );
+
+ const TMinimumSpanningTree* GetMinimumSpanningTree( ) const;
+ const TImage* GetImage( ) const;
+ void SetMinimumSpanningTree( const TMinimumSpanningTree* mst );
+ void SetImage( const TImage* image );
+
+ protected:
+ PathToPolyDataFilter( );
+ virtual ~PathToPolyDataFilter( );
+
+ int RequestData(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ );
+ int RequestInformation(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ );
+
+ virtual void _PrepareOutput( vtkPolyData* out );
+
+ private:
+ // Purposely not implemented
+ PathToPolyDataFilter( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ const TMinimumSpanningTree* m_MST;
+ const TImage* m_Image;
+ TVertex Seed0;
+ TVertex Seed1;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+# include <fpa/VTK/Image/PathToPolyDataFilter.hxx>
+#endif // ITK_MANUAL_INSTANTIATION
+
+#endif // __FPA__VTK__IMAGE__PATHTOPOLYDATAFILTER__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPA__VTK__IMAGE__PATHTOPOLYDATAFILTER__HXX__
+#define __FPA__VTK__IMAGE__PATHTOPOLYDATAFILTER__HXX__
+
+#include <vtkCellArray.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
+#include <vtkPointData.h>
+#include <vtkPoints.h>
+#include <vtkSmartPointer.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+typename fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+Self* fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+New( )
+{
+ return( new Self( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+const typename fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+TMinimumSpanningTree*
+fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+GetMinimumSpanningTree( ) const
+{
+ return( this->m_MST );
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+const typename fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+TImage* fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+GetImage( ) const
+{
+ return( this->m_Image );
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+void fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+SetMinimumSpanningTree( const TMinimumSpanningTree* mst )
+{
+ if( this->m_MST != mst )
+ {
+ this->m_MST = mst;
+ this->Modified( );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+void fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+SetImage( const TImage* image )
+{
+ if( this->m_Image != image )
+ {
+ this->m_Image = image;
+ this->Modified( );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+PathToPolyDataFilter( )
+ : vtkPolyDataAlgorithm( ),
+ m_MST( NULL ),
+ m_Image( NULL )
+{
+ this->SetNumberOfInputPorts( 0 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+~PathToPolyDataFilter( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+int fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+RequestData(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ )
+{
+ if( this->m_MST == NULL || this->m_Image == NULL )
+ return( 0 );
+ auto path = this->m_MST->GetPath( this->Seed0, this->Seed1 );
+ if( path.size( ) == 0 )
+ return( 0 );
+
+ // Prepare output
+ vtkInformation* info = output->GetInformationObject( 0 );
+ vtkPolyData* out = vtkPolyData::SafeDownCast(
+ info->Get( vtkDataObject::DATA_OBJECT( ) )
+ );
+ this->_PrepareOutput( out );
+ vtkPoints* points = out->GetPoints( );
+ vtkCellArray* lines = out->GetLines( );
+
+ unsigned int i = 0;
+ for( auto pIt = path.begin( ); pIt != path.end( ); ++pIt, ++i )
+ {
+ typename TImage::PointType p;
+ this->m_Image->TransformIndexToPhysicalPoint( *pIt, p );
+ if( TImage::ImageDimension == 1 )
+ points->InsertNextPoint( double( p[ 0 ] ), double( 0 ), double( 0 ) );
+ else if( TImage::ImageDimension == 2 )
+ points->InsertNextPoint( double( p[ 0 ] ), double( p[ 1 ] ), double( 0 ) );
+ else if( TImage::ImageDimension > 2 )
+ points->InsertNextPoint( double( p[ 0 ] ), double( p[ 1 ] ), double( p[ 2 ] ) );
+
+ if( i > 0 )
+ {
+ lines->InsertNextCell( 2 );
+ lines->InsertCellPoint( i - 1 );
+ lines->InsertCellPoint( i );
+
+ } // fi
+
+ } // rof
+ out->Modified( );
+ return( 1 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+int fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+RequestInformation(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ )
+{
+ vtkInformation* out = output->GetInformationObject( 0 );
+ out->Set( CAN_HANDLE_PIECE_REQUEST( ), 1 );
+ return( 1 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TMinimumSpanningTree >
+void fpa::VTK::Image::PathToPolyDataFilter< _TMinimumSpanningTree >::
+_PrepareOutput( vtkPolyData* out )
+{
+ // Prepare points
+ vtkPoints* points = out->GetPoints( );
+ if( points == NULL )
+ {
+ points = vtkPoints::New( );
+ out->SetPoints( points );
+ points->Delete( );
+
+ } // fi
+
+ // Prepare points
+ vtkCellArray* lines = out->GetLines( );
+ if( lines == NULL )
+ {
+ lines = vtkCellArray::New( );
+ out->SetLines( lines );
+ out->SetVerts( vtkCellArray::New( ) );
+ out->SetPolys( vtkCellArray::New( ) );
+ out->SetStrips( vtkCellArray::New( ) );
+ lines->Delete( );
+
+ } // fi
+}
+
+#endif // __FPA__VTK__IMAGE__PATHTOPOLYDATAFILTER__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+## ==========================
+## == Build plugin library ==
+## ==========================
+Wrap_cpPlugins(
+ _plugin
+ ${CMAKE_CURRENT_SOURCE_DIR}/Plugins
+ ${prj_VERSION} ${prj_SHORT_VERSION}
+ fpa
+ )
+TARGET_LINK_LIBRARIES(${_plugin} ${cpPlugins_LIB} ${fpa_Instances})
+
+## eof - $RCSfile$
--- /dev/null
+#include "BaseImageFilter.h"
+#include <cpPlugins/DataObjects/Image.h>
+
+// -------------------------------------------------------------------------
+bool fpaPlugins::BaseImageFilter::
+IsInteractive( )
+{
+ return( true );
+}
+
+// -------------------------------------------------------------------------
+/* TODO
+ void fpaPlugins::BaseImageFilter::
+ SetInteractionObjects( const std::vector< void* >& objs )
+ {
+ if( objs.size( ) > 0 )
+ this->m_SingleInteractor =
+ reinterpret_cast< vtkRenderWindowInteractor* >( objs[ 0 ] );
+ if( objs.size( ) > 1 )
+ this->m_MPRViewer = reinterpret_cast< TMPRWidget* >( objs[ 1 ] );
+ }
+*/
+
+// -------------------------------------------------------------------------
+fpaPlugins::BaseImageFilter::
+BaseImageFilter( )
+ : Superclass( )
+{
+ this->_ConfigureInput< cpPlugins::DataObjects::Image >( "Input", true, false );
+ this->_ConfigureInput< cpPlugins::BaseObjects::DataObject >( "Seeds", true, false );
+ this->_ConfigureOutput< cpPlugins::DataObjects::Image >( "Output" );
+
+ this->m_Parameters.ConfigureAsBool( "VisualDebug" );
+ this->m_Parameters.ConfigureAsBool( "StopAtOneFront" );
+ this->m_Parameters.SetBool( "VisualDebug", false );
+ this->m_Parameters.SetBool( "StopAtOneFront", false );
+
+ std::vector< std::string > orders;
+ orders.push_back( "1" );
+ orders.push_back( "2" );
+ this->m_Parameters.ConfigureAsChoices( "NeighborhoodOrder", orders );
+ this->m_Parameters.SetSelectedChoice( "NeighborhoodOrder", "1" );
+}
+
+// -------------------------------------------------------------------------
+fpaPlugins::BaseImageFilter::
+~BaseImageFilter( )
+{
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPAPLUGINS__BASEIMAGEFILTER__H__
+#define __FPAPLUGINS__BASEIMAGEFILTER__H__
+
+#include <fpa/Config.h>
+#include <plugins/fpaPlugins_Export.h>
+#include <cpPlugins/BaseObjects/ProcessObject.h>
+
+#include <cpExtensions/QT/SimpleMPRWidget.h>
+#include <vtkRenderWindowInteractor.h>
+
+namespace fpaPlugins
+{
+ /**
+ */
+ class fpaPlugins_EXPORT BaseImageFilter
+ : public cpPlugins::BaseObjects::ProcessObject
+ {
+ public:
+ typedef BaseImageFilter Self;
+ typedef cpPlugins::BaseObjects::ProcessObject Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef cpExtensions::QT::SimpleMPRWidget TMPRWidget;
+
+ public:
+ itkTypeMacro( BaseImageFilter, cpPlugins::BaseObjects::ProcessObject );
+ cpPlugins_Id_Macro( BaseImageFilter, fpaImageAlgorithm );
+
+ public:
+ virtual bool IsInteractive( ) fpa_OVERRIDE;
+ /* TODO
+ virtual void SetInteractionObjects(
+ const std::vector< void* >& objs
+ ) override;
+ */
+
+ protected:
+ BaseImageFilter( );
+ virtual ~BaseImageFilter( );
+
+ template< class _TFilter >
+ inline _TFilter* _ConfigureFilter( );
+
+ template< class _TFilter >
+ inline void _ExecuteFilter( _TFilter* filter );
+
+ template< class _TFilter >
+ inline void _ConfigureDebugger( _TFilter* filter );
+
+ template< class _TFilter >
+ inline void _DeconfigureDebugger( _TFilter* filter );
+
+ private:
+ // Purposely not implemented.
+ BaseImageFilter( const Self& other );
+ Self& operator=( const Self& other );
+
+ protected:
+ std::set< unsigned long > m_Observers;
+ };
+
+} // ecapseman
+
+#include "BaseImageFilter.hxx"
+
+#endif // __FPAPLUGINS__BASEIMAGEFILTER__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPAPLUGINS__BASEIMAGEFILTER__HXX__
+#define __FPAPLUGINS__BASEIMAGEFILTER__HXX__
+
+#include <vtkPolyData.h>
+
+/* TODO
+ #include <fpa/VTK/Image/Observer2D.h>
+ #include <fpa/VTK/Image/Observer2D.hxx>
+*/
+#include <fpa/VTK/Image/Observer3D.h>
+#include <fpa/VTK/Image/Observer3D.hxx>
+
+// -------------------------------------------------------------------------
+template< class _TFilter >
+_TFilter* fpaPlugins::BaseImageFilter::
+_ConfigureFilter( )
+{
+ typedef typename _TFilter::TInputImage _TImage;
+ static const unsigned int Dim = _TImage::ImageDimension;
+
+ auto image = this->GetInputData< _TImage >( "Input" );
+ if( image == NULL )
+ return( NULL );
+ auto seeds = this->GetInputData< vtkPolyData >( "Seeds" )->GetPoints( );
+
+ // Create filter and connect input
+ auto filter = this->_CreateITK< _TFilter >( );
+ filter->SetInput( image );
+
+ // Set numeric parameters
+ filter->SetNeighborhoodOrder(
+ this->m_Parameters.GetSelectedChoice( "NeighborhoodOrder" )[ 0 ] - '0'
+ );
+ filter->SetStopAtOneFront( this->m_Parameters.GetBool( "StopAtOneFront" ) );
+
+ // Assign seeds
+ filter->RemoveAllSeeds( );
+ if( seeds != NULL )
+ {
+ typename _TImage::PointType pnt;
+ typename _TImage::IndexType idx;
+ unsigned int dim =
+ ( _TImage::ImageDimension < 3 )? _TImage::ImageDimension: 3;
+ for( unsigned int i = 0; i < seeds->GetNumberOfPoints( ); ++i )
+ {
+ double buf[ 3 ];
+ seeds->GetPoint( i, buf );
+ pnt.Fill( 0 );
+ for( unsigned int d = 0; d < dim; ++d )
+ pnt[ d ] = buf[ d ];
+
+ if( image->TransformPhysicalPointToIndex( pnt, idx ) )
+ filter->AddSeed( idx, 0 );
+
+ } // rof
+
+ } // fi
+
+ // Ok!
+ return( filter );
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter >
+void fpaPlugins::BaseImageFilter::
+_ExecuteFilter( _TFilter* filter )
+{
+ // Go!!!
+ this->_ConfigureDebugger( filter );
+ filter->Update( );
+ this->_DeconfigureDebugger( filter );
+
+ // Connect output
+ this->GetOutput( "Output" )->SetITK( filter->GetOutput( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TFilter >
+void fpaPlugins::BaseImageFilter::
+_ConfigureDebugger( _TFilter* filter )
+{
+ typedef typename _TFilter::TInputImage _TImage;
+ typedef fpa::VTK::Image::Observer3D< _TFilter, vtkRenderWindow > _3D;
+
+ /* TODO
+ typedef fpa::VTK::Image::Observer2D< _TFilter, vtkRenderWindow > _2D;
+ */
+
+ this->m_Observers.clear( );
+ if( this->m_Parameters.GetBool( "VisualDebug" ) )
+ {
+ if( _TImage::ImageDimension == 2 )
+ {
+ }
+ else if( _TImage::ImageDimension == 3 )
+ {
+ /* TODO
+ auto iren = this->m_MPRViewer->GetInteractor( 3 );
+ if( iren != NULL )
+ {
+ typename _3D::Pointer debugger = _3D::New( );
+ debugger->SetRenderWindow( iren->GetRenderWindow( ) );
+ debugger->SetRenderPercentage( 0.001 );
+ this->m_Observers.insert(
+ filter->AddObserver( itk::AnyEvent( ), debugger )
+ );
+ filter->ThrowEventsOn( );
+
+ } // fi
+ */
+
+ } // fi
+
+ /* TODO
+ if( this->m_SingleInteractor != NULL )
+ {
+ if( _TImage::ImageDimension == 2 )
+ {
+ }
+ else if( _TImage::ImageDimension == 3 )
+ {
+ } // fi
+
+ } // fi
+
+ */
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class F >
+void fpaPlugins::BaseImageFilter::
+_DeconfigureDebugger( F* filter )
+{
+ /* TODO
+ if( filter != NULL )
+ {
+ auto oIt = this->m_Observers.begin( );
+ for( ; oIt != this->m_Observers.end( ); ++oIt )
+ filter->RemoveObserver( *oIt );
+
+ } // fi
+ this->m_Observers.clear( );
+ */
+}
+
+#endif // __FPAPLUGINS__BASEIMAGEFILTER__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+#include "GaussianCostFunctor.h"
+
+#include <fpa/Base/Functors/GaussianCost.h>
+#include <fpa/Base/Functors/GaussianCost.hxx>
+
+// -------------------------------------------------------------------------
+fpaPlugins::GaussianCostFunctor::
+GaussianCostFunctor( )
+ : Superclass( )
+{
+ this->_ConfigureOutput< cpPlugins::BaseObjects::DataObject >( "Output" );
+ this->_ConfigureOutput< cpPlugins::BaseObjects::DataObject >( "Estimator" );
+ std::vector< std::string > choices;
+ choices.push_back( "float" );
+ choices.push_back( "double" );
+ this->m_Parameters.ConfigureAsChoices( "ResultType", choices );
+ this->m_Parameters.SetSelectedChoice( "ResultType", "float" );
+ this->m_Parameters.ConfigureAsUint( "SupportSize" );
+ this->m_Parameters.ConfigureAsReal( "MinimumCost" );
+ this->m_Parameters.SetUint( "SupportSize", 30 );
+ this->m_Parameters.SetReal( "MinimumCost", 1e-5 );
+}
+
+// -------------------------------------------------------------------------
+fpaPlugins::GaussianCostFunctor::
+~GaussianCostFunctor( )
+{
+}
+
+// -------------------------------------------------------------------------
+void fpaPlugins::GaussianCostFunctor::
+_GenerateData( )
+{
+ auto rtype = this->m_Parameters.GetSelectedChoice( "ResultType" );
+ if ( rtype == "float" ) this->_GD0< float >( );
+ else if( rtype == "double" ) this->_GD0< double >( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+void fpaPlugins::GaussianCostFunctor::
+_GD0( )
+{
+ typedef fpa::Base::Functors::GaussianCost< _TResult > _TFunctor;
+ auto out = this->GetOutput( "Output" );
+ auto f = out->GetITK< _TFunctor >( );
+ if( f == NULL )
+ {
+ typename _TFunctor::Pointer ptr_f = _TFunctor::New( );
+ f = ptr_f.GetPointer( );
+ out->SetITK( f );
+
+ } // fi
+ f->SetSupportSize( this->m_Parameters.GetUint( "SupportSize" ) );
+ f->SetMinimumCost( this->m_Parameters.GetReal( "MinimumCost" ) );
+ this->GetOutput( "Estimator" )->SetITK( f->GetModel( ) );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPAPLUGINS__GAUSSIANCOSTFUNCTOR__H__
+#define __FPAPLUGINS__GAUSSIANCOSTFUNCTOR__H__
+
+#include <plugins/fpaPlugins_Export.h>
+#include <cpPlugins/BaseObjects/ProcessObject.h>
+
+namespace fpaPlugins
+{
+ /**
+ */
+ class fpaPlugins_EXPORT GaussianCostFunctor
+ : public cpPlugins::BaseObjects::ProcessObject
+ {
+ cpPluginsObject(
+ GaussianCostFunctor,
+ cpPlugins::BaseObjects::ProcessObject,
+ fpaFunctors
+ );
+
+ protected:
+ template< class _TResult >
+ inline void _GD0( );
+ };
+
+} // ecapseman
+
+#endif // __FPAPLUGINS__GAUSSIANCOSTFUNCTOR__H__
+
+// eof - $RCSfile$
--- /dev/null
+#include "ImageDijkstra.h"
+// TODO: #include "MinimumSpanningTree.h"
+
+#include <cpPlugins/DataObjects/Image.h>
+#include <fpa/Image/Dijkstra.h>
+
+#include <fpa/Base/Algorithm.hxx>
+#include <fpa/Base/Dijkstra.hxx>
+#include <fpa/Image/Algorithm.hxx>
+#include <fpa/Image/Dijkstra.hxx>
+
+// -------------------------------------------------------------------------
+fpaPlugins::ImageDijkstra::
+ImageDijkstra( )
+ : Superclass( )
+{
+ this->_ConfigureInput< cpPlugins::BaseObjects::DataObject >( "CostFunctor", false, false );
+ this->_ConfigureOutput< cpPlugins::BaseObjects::DataObject >( "MST" );
+ std::vector< std::string > choices;
+ choices.push_back( "float" );
+ choices.push_back( "double" );
+ this->m_Parameters.ConfigureAsChoices( "ResultType", choices );
+ this->m_Parameters.SetSelectedChoice( "ResultType", "float" );
+ this->m_Parameters.ConfigureAsBool( "FillNodeQueue" );
+ this->m_Parameters.SetBool( "FillNodeQueue", false );
+}
+
+// -------------------------------------------------------------------------
+fpaPlugins::ImageDijkstra::
+~ImageDijkstra( )
+{
+}
+
+// -------------------------------------------------------------------------
+void fpaPlugins::ImageDijkstra::
+_GenerateData( )
+{
+ auto o = this->GetInputData( "Input" );
+ cpPlugins_Demangle_ImageScalars_Dims( o, _GD0 );
+ else this->_Error( "Invalid input image." );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage >
+void fpaPlugins::ImageDijkstra::
+_GD0( _TImage* image )
+{
+ auto rtype = this->m_Parameters.GetSelectedChoice( "ResultType" );
+ if( rtype == "float" ) this->_GD1< _TImage, float >( image );
+ else if( rtype == "double" ) this->_GD1< _TImage, double >( image );
+}
+
+// -------------------------------------------------------------------------
+template< class _TInputImage, class _TOutput >
+void fpaPlugins::ImageDijkstra::
+_GD1( _TInputImage* input )
+{
+ typedef itk::Image< _TOutput, _TInputImage::ImageDimension > _TOutputImage;
+ typedef fpa::Image::Dijkstra< _TInputImage, _TOutputImage > _TFilter;
+ typedef typename _TFilter::TCostConversionFunction _TCostFunctor;
+
+ // Get functor
+ auto base_functor =
+ this->GetInputData< itk::LightObject >( "CostFunctor" );
+ _TCostFunctor* functor = NULL;
+ if( base_functor != NULL )
+ {
+ functor = dynamic_cast< _TCostFunctor* >( base_functor );
+ if( functor == NULL )
+ this->_Error( "Given cost functor is invalid." );
+
+ } // fi
+
+ // Create filter
+ _TFilter* filter = this->_ConfigureFilter< _TFilter >( );
+ // TODO: filter->SetFillNodeQueue( this->m_Parameters.GetBool( "FillNodeQueue" ) );
+ filter->SetCostConversionFunction( functor );
+
+ // Go!!!
+ this->_ExecuteFilter( filter );
+
+ // Connect remaining output
+ this->GetOutput( "MST" )->SetITK( filter->GetMinimumSpanningTree( ) );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPAPLUGINS__IMAGEDIJKSTRA__H__
+#define __FPAPLUGINS__IMAGEDIJKSTRA__H__
+
+#include "BaseImageFilter.h"
+
+namespace fpaPlugins
+{
+ /**
+ */
+ class fpaPlugins_EXPORT ImageDijkstra
+ : public BaseImageFilter
+ {
+ cpPluginsObject( ImageDijkstra, BaseImageFilter, fpa );
+
+ protected:
+ template< class _TImage >
+ inline void _GD0( _TImage* image );
+
+ template< class _TInputImage, class _TOutput >
+ inline void _GD1( _TInputImage* input );
+ };
+
+} // ecapseman
+
+#endif // __FPAPLUGINS__IMAGEDIJKSTRA__H__
+
+// eof - $RCSfile$
--- /dev/null
+#include "ImagePathToPolyDataFilter.h"
+#include <cpPlugins/DataObjects/Image.h>
+#include <cpPlugins/DataObjects/Mesh.h>
+#include <fpa/Base/MinimumSpanningTree.h>
+#include <fpa/VTK/Image/PathToPolyDataFilter.h>
+#include <fpa/VTK/Image/PathToPolyDataFilter.hxx>
+
+// -------------------------------------------------------------------------
+fpaPlugins::ImagePathToPolyDataFilter::
+ImagePathToPolyDataFilter( )
+ : Superclass( )
+{
+ this->_ConfigureInput< cpPlugins::BaseObjects::DataObject >( "MST", true, false );
+ this->_ConfigureInput< cpPlugins::DataObjects::Image >( "Image", true, false );
+ this->_ConfigureInput< cpPlugins::BaseObjects::DataObject >( "Seeds", true, false );
+ this->_ConfigureOutput< cpPlugins::DataObjects::Mesh >( "Output" );
+
+ this->m_Parameters.ConfigureAsUint( "Seed0" );
+ this->m_Parameters.ConfigureAsUint( "Seed1" );
+ this->m_Parameters.SetUint( "Seed0", 0 );
+ this->m_Parameters.SetUint( "Seed1", 1 );
+}
+
+// -------------------------------------------------------------------------
+fpaPlugins::ImagePathToPolyDataFilter::
+~ImagePathToPolyDataFilter( )
+{
+}
+
+// -------------------------------------------------------------------------
+void fpaPlugins::ImagePathToPolyDataFilter::
+_GenerateData( )
+{
+ auto i2 = this->GetInputData< itk::ImageBase< 2 > >( "Image" );
+ auto i3 = this->GetInputData< itk::ImageBase< 3 > >( "Image" );
+ if( i2 != NULL )
+ this->_GD0( i2 );
+ else if( i3 != NULL )
+ this->_GD0( i3 );
+ else
+ this->_Error( "No valid input image." );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage >
+void fpaPlugins::ImagePathToPolyDataFilter::
+_GD0( _TImage* image )
+{
+ typedef typename _TImage::IndexType _TIndex;
+ typedef typename _TIndex::LexicographicCompare _TComp;
+ typedef fpa::Base::MinimumSpanningTree< _TIndex, float, _TComp > _TFloat;
+ typedef fpa::Base::MinimumSpanningTree< _TIndex, double, _TComp > _TDouble;
+
+ auto mf = this->GetInputData< _TFloat >( "MST" );
+ auto md = this->GetInputData< _TDouble >( "MST" );
+ if( mf != NULL )
+ this->_GD1( image, mf );
+ else if( md != NULL )
+ this->_GD1( image, md );
+ else
+ this->_Error( "No valid input minimum spanning tree." );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage, class _TMST >
+void fpaPlugins::ImagePathToPolyDataFilter::
+_GD1( _TImage* image, _TMST* mst )
+{
+ typedef fpa::VTK::Image::PathToPolyDataFilter< _TMST > _TFilter;
+ auto seeds = this->GetInputData< vtkPolyData >( "Seeds" )->GetPoints( );
+ if( seeds->GetNumberOfPoints( ) < 2 )
+ this->_Error( "Not enough seeds." );
+
+ auto filter = this->_CreateVTK< _TFilter >( );
+ filter->SetImage( image );
+ filter->SetMinimumSpanningTree( mst );
+
+ typename _TImage::PointType pnt;
+ typename _TImage::IndexType idx;
+ unsigned int dim =
+ ( _TImage::ImageDimension < 3 )? _TImage::ImageDimension: 3;
+ double buf[ 3 ];
+ seeds->GetPoint( this->m_Parameters.GetUint( "Seed0" ), buf );
+ pnt.Fill( 0 );
+ for( unsigned int d = 0; d < dim; ++d )
+ pnt[ d ] = buf[ d ];
+ if( image->TransformPhysicalPointToIndex( pnt, idx ) )
+ filter->SetSeed0( idx );
+ seeds->GetPoint( this->m_Parameters.GetUint( "Seed1" ), buf );
+ pnt.Fill( 0 );
+ for( unsigned int d = 0; d < dim; ++d )
+ pnt[ d ] = buf[ d ];
+ if( image->TransformPhysicalPointToIndex( pnt, idx ) )
+ filter->SetSeed1( idx );
+ filter->Update( );
+ this->GetOutput( "Output" )->SetVTK( filter->GetOutput( ) );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPAPLUGINS__IMAGEPATHTOPOLYDATAFILTER__H__
+#define __FPAPLUGINS__IMAGEPATHTOPOLYDATAFILTER__H__
+
+#include <plugins/fpaPlugins_Export.h>
+#include <cpPlugins/BaseObjects/ProcessObject.h>
+
+namespace fpaPlugins
+{
+ /**
+ */
+ class fpaPlugins_EXPORT ImagePathToPolyDataFilter
+ : public cpPlugins::BaseObjects::ProcessObject
+ {
+ cpPluginsObject(
+ ImagePathToPolyDataFilter,
+ cpPlugins::BaseObjects::ProcessObject,
+ fpaImageAlgorithm
+ );
+
+ protected:
+ template< class _TImage >
+ inline void _GD0( _TImage* image );
+
+ template< class _TImage, class _TMST >
+ inline void _GD1( _TImage* image, _TMST* mst );
+ };
+
+} // ecapseman
+
+#endif // __FPAPLUGINS__IMAGEPATHTOPOLYDATAFILTER__H__
+
+// eof - $RCSfile$
--- /dev/null
+#include "InvertCostFunctor.h"
+
+#include <fpa/Base/Functors/InvertCost.h>
+#include <fpa/Base/Functors/InvertCost.hxx>
+
+// -------------------------------------------------------------------------
+fpaPlugins::InvertCostFunctor::
+InvertCostFunctor( )
+ : Superclass( )
+{
+ this->_ConfigureOutput< cpPlugins::BaseObjects::DataObject >( "Output" );
+ std::vector< std::string > choices;
+ choices.push_back( "float" );
+ choices.push_back( "double" );
+ this->m_Parameters.ConfigureAsChoices( "ResultType", choices );
+ this->m_Parameters.SetSelectedChoice( "ResultType", "float" );
+}
+
+// -------------------------------------------------------------------------
+fpaPlugins::InvertCostFunctor::
+~InvertCostFunctor( )
+{
+}
+
+// -------------------------------------------------------------------------
+void fpaPlugins::InvertCostFunctor::
+_GenerateData( )
+{
+ auto rtype = this->m_Parameters.GetSelectedChoice( "ResultType" );
+ if ( rtype == "float" ) this->_GD0< float >( );
+ else if( rtype == "double" ) this->_GD0< double >( );
+}
+
+// -------------------------------------------------------------------------
+template< class _TResult >
+void fpaPlugins::InvertCostFunctor::
+_GD0( )
+{
+ typedef fpa::Base::Functors::InvertCost< _TResult > _TFunctor;
+ auto out = this->GetOutput( "Output" );
+ auto f = out->GetITK< _TFunctor >( );
+ if( f == NULL )
+ {
+ typename _TFunctor::Pointer ptr_f = _TFunctor::New( );
+ f = ptr_f.GetPointer( );
+ out->SetITK( f );
+
+ } // fi
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __FPAPLUGINS__INVERTCOSTFUNCTOR__H__
+#define __FPAPLUGINS__INVERTCOSTFUNCTOR__H__
+
+#include <plugins/fpaPlugins_Export.h>
+#include <cpPlugins/BaseObjects/ProcessObject.h>
+
+namespace fpaPlugins
+{
+ /**
+ */
+ class fpaPlugins_EXPORT InvertCostFunctor
+ : public cpPlugins::BaseObjects::ProcessObject
+ {
+ cpPluginsObject(
+ InvertCostFunctor,
+ cpPlugins::BaseObjects::ProcessObject,
+ fpaFunctors
+ );
+
+ protected:
+ template< class _TResult >
+ inline void _GD0( );
+ };
+
+} // ecapseman
+
+#endif // __FPAPLUGINS__INVERTCOSTFUNCTOR__H__
+
+// eof - $RCSfile$
--- /dev/null
+#include "MultiplyImageAndDistanceMap.h"
+#include <cpPlugins/DataObjects/Image.h>
+
+#include <fpa/Image/MultiplyImageAndDistanceMap.h>
+#include <fpa/Image/MultiplyImageAndDistanceMap.hxx>
+
+/* TODO
+ #include <fpa/Image/Dijkstra.h>
+ #include <fpa/Base/Algorithm.hxx>
+ #include <fpa/Base/Dijkstra.hxx>
+ #include <fpa/Image/Algorithm.hxx>
+ #include <fpa/Image/Dijkstra.hxx>
+*/
+
+// -------------------------------------------------------------------------
+fpaPlugins::MultiplyImageAndDistanceMap::
+MultiplyImageAndDistanceMap( )
+ : Superclass( )
+{
+ typedef cpPlugins::DataObjects::Image _TImage;
+ this->_ConfigureInput< _TImage >( "Input", true, false );
+ this->_ConfigureInput< _TImage >( "DistanceMap", true, false );
+ this->_ConfigureOutput< _TImage >( "Output" );
+
+ /* TODO
+ this->_ConfigureOutput< cpPlugins::BaseObjects::DataObject >( "MST" );
+ std::vector< std::string > choices;
+ choices.push_back( "float" );
+ choices.push_back( "double" );
+ this->m_Parameters.ConfigureAsChoices( "ResultType", choices );
+ this->m_Parameters.SetSelectedChoice( "ResultType", "float" );
+ this->m_Parameters.ConfigureAsBool( "FillNodeQueue" );
+ this->m_Parameters.SetBool( "FillNodeQueue", false );
+ */
+}
+
+// -------------------------------------------------------------------------
+fpaPlugins::MultiplyImageAndDistanceMap::
+~MultiplyImageAndDistanceMap( )
+{
+}
+
+// -------------------------------------------------------------------------
+void fpaPlugins::MultiplyImageAndDistanceMap::
+_GenerateData( )
+{
+ auto o = this->GetInputData( "Input" );
+ cpPlugins_Demangle_ImageScalars_Dims( o, _GD0 );
+ else this->_Error( "Invalid input image." );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage >
+void fpaPlugins::MultiplyImageAndDistanceMap::
+_GD0( _TImage* image )
+{
+ typedef itk::Image< float, _TImage::ImageDimension > _TFloat;
+ typedef itk::Image< double, _TImage::ImageDimension > _TDouble;
+
+ auto f = this->GetInputData< _TFloat >( "DistanceMap" );
+ auto d = this->GetInputData< _TDouble >( "DistanceMap" );
+ if ( f != NULL ) this->_GD1( image, f );
+ else if( d != NULL ) this->_GD1( image, d );
+ else this->_Error( "Invalid distance map." );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage, class _TDistanceMap >
+ void fpaPlugins::MultiplyImageAndDistanceMap::
+_GD1( _TImage* input, _TDistanceMap* dmap )
+{
+ typedef fpa::Image::MultiplyImageAndDistanceMap< _TImage, _TDistanceMap > _TFilter;
+
+ auto filter = this->_CreateITK< _TFilter >( );
+ filter->SetInput( input );
+ filter->SetDistanceMap( dmap );
+ filter->Update( );
+ this->GetOutput( "Output" )->SetITK( filter->GetOutput( ) );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __fpaPlugins__MultiplyImageAndDistanceMap__h__
+#define __fpaPlugins__MultiplyImageAndDistanceMap__h__
+
+#include <fpa/Config.h>
+#include <plugins/fpaPlugins_Export.h>
+#include <cpPlugins/BaseObjects/ProcessObject.h>
+
+namespace fpaPlugins
+{
+ /**
+ */
+ class fpaPlugins_EXPORT MultiplyImageAndDistanceMap
+ : public cpPlugins::BaseObjects::ProcessObject
+ {
+ cpPluginsObject(
+ MultiplyImageAndDistanceMap, cpPlugins::BaseObjects::ProcessObject, fpa
+ );
+
+ protected:
+ template< class _TImage >
+ inline void _GD0( _TImage* image );
+
+ template< class _TImage, class _TDistanceMap >
+ inline void _GD1( _TImage* input, _TDistanceMap* dmap );
+ };
+
+} // ecapseman
+
+#endif // __fpaPlugins__MultiplyImageAndDistanceMap__h__
+
+// eof - $RCSfile$
git://git.creatis.insa-lyon.fr / FrontAlgorithms.git / commitdiff